+
+
+
+
+
+
+
+
+
+
+
diff --git a/LICENSE b/LICENSE
deleted file mode 100644
index 2671ba32cb..0000000000
--- a/LICENSE
+++ /dev/null
@@ -1,29 +0,0 @@
-BSD 3-Clause License
-
-Copyright (c) 2016-2022, Runtime Verification Inc.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
- list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
- this list of conditions and the following disclaimer in the documentation
- and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its
- contributors may be used to endorse or promote products derived from
- this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/Makefile b/Makefile
deleted file mode 100644
index 6826796a64..0000000000
--- a/Makefile
+++ /dev/null
@@ -1,180 +0,0 @@
-all: poetry
-
-
-# Building
-# --------
-
-PYTHON_BIN := python3.10
-KEVM_PYK_DIR := ./kevm-pyk
-POETRY := poetry -C $(KEVM_PYK_DIR)
-POETRY_RUN := $(POETRY) run --
-
-
-.PHONY: poetry-env
-poetry-env:
- $(POETRY) env use $(PYTHON_BIN)
-
-poetry: poetry-env
- $(POETRY) install
-
-shell: poetry
- $(POETRY) shell
-
-kevm-pyk: poetry-env
- $(MAKE) -C $(KEVM_PYK_DIR)
-
-
-# Tests
-# -----
-
-test: test-integration test-conformance test-prove test-prove-pyk test-prove-kprove test-interactive
-
-
-# Conformance Tests
-
-test-conformance: poetry
- $(MAKE) -C kevm-pyk/ test-integration PYTEST_ARGS+="-k test_conformance.py"
-
-test-vm: poetry
- $(MAKE) -C kevm-pyk/ test-integration PYTEST_ARGS+="-k test_vm"
-
-test-rest-vm: poetry
- $(MAKE) -C kevm-pyk/ test-integration PYTEST_ARGS+="-k test_rest_vm"
-
-test-bchain: poetry
- $(MAKE) -C kevm-pyk/ test-integration PYTEST_ARGS+="-k test_bchain"
-
-test-rest-bchain: poetry
- $(MAKE) -C kevm-pyk/ test-integration PYTEST_ARGS+="-k test_rest_bchain"
-
-
-# Proof Tests
-
-test-prove: test-prove-pyk test-prove-kprove
-
-test-prove-pyk: tests/specs/opcodes/evm-optimizations-spec.md poetry
- $(MAKE) -C kevm-pyk/ test-integration PYTEST_ARGS+="-k test_pyk_prove"
-
-test-prove-kprove: tests/specs/opcodes/evm-optimizations-spec.md poetry
- $(MAKE) -C kevm-pyk/ test-integration PYTEST_ARGS+="-k test_kprove_prove"
-
-# to generate optimizations.md, run: ./optimizer/optimize.sh &> output
-tests/specs/opcodes/evm-optimizations-spec.md: kevm-pyk/src/kevm_pyk/kproj/evm-semantics/optimizations.md
- cat kevm-pyk/src/kevm_pyk/kproj/evm-semantics/optimizations.md | sed 's/^rule/claim/' | sed 's/EVM-OPTIMIZATIONS/EVM-OPTIMIZATIONS-SPEC/' | grep -v 'priority(40)' > $@
-
-
-# Integration Tests
-
-test-integration: poetry
- $(MAKE) -C kevm-pyk/ test-integration PYTEST_ARGS+='-k "(test_kast.py or test_run.py or test_solc_to_k.py)"'
-
-profile: poetry
- $(MAKE) -C kevm-pyk/ profile
- find /tmp/pytest-of-$$(whoami)/pytest-current/ -type f -name '*.prof' | sort | xargs tail -n +1
-
-
-# Smoke Tests
-
-TEST_SYMBOLIC_BACKEND := haskell
-
-KPROVE_MODULE = VERIFICATION
-KPROVE_FILE = verification
-KPROVE_EXT = k
-
-KEVM_OPTS ?=
-KPROVE_OPTS ?=
-
-
-tests/specs/examples/%-bin-runtime.k: KEVM_OPTS += --verbose
-
-tests/specs/examples/erc20-spec/haskell/timestamp: tests/specs/examples/erc20-bin-runtime.k
-tests/specs/examples/erc20-bin-runtime.k: tests/specs/examples/ERC20.sol $(KEVM_LIB)/$(haskell_kompiled) poetry
- $(KEVM) solc-to-k $< ERC20 $(KEVM_OPTS) --verbose --definition $(KEVM_LIB)/$(haskell_dir) --main-module ERC20-VERIFICATION > $@
-
-tests/specs/examples/erc721-spec/haskell/timestamp: tests/specs/examples/erc721-bin-runtime.k
-tests/specs/examples/erc721-bin-runtime.k: tests/specs/examples/ERC721.sol $(KEVM_LIB)/$(haskell_kompiled) poetry
- $(KEVM) solc-to-k $< ERC721 $(KEVM_OPTS) --verbose --definition $(KEVM_LIB)/$(haskell_dir) --main-module ERC721-VERIFICATION > $@
-
-tests/specs/examples/storage-spec/haskell/timestamp: tests/specs/examples/storage-bin-runtime.k
-tests/specs/examples/storage-bin-runtime.k: tests/specs/examples/Storage.sol $(KEVM_LIB)/$(haskell_kompiled) poetry
- $(KEVM) solc-to-k $< Storage $(KEVM_OPTS) --verbose --definition $(KEVM_LIB)/$(haskell_dir) --main-module STORAGE-VERIFICATION > $@
-
-tests/specs/examples/empty-bin-runtime.k: tests/specs/examples/Empty.sol $(KEVM_LIB)/$(haskell_kompiled) poetry
- $(KEVM) solc-to-k $< Empty $(KEVM_OPTS) --verbose --definition $(KEVM_LIB)/$(haskell_dir) --main-module EMPTY-VERIFICATION > $@
-
-.SECONDEXPANSION:
-tests/specs/%.prove: tests/specs/% tests/specs/$$(firstword $$(subst /, ,$$*))/$$(KPROVE_FILE)/$(TEST_SYMBOLIC_BACKEND)/timestamp
- $(POETRY_RUN) kevm-pyk prove $< $(KEVM_OPTS) $(KPROVE_OPTS) \
- --definition tests/specs/$(firstword $(subst /, ,$*))/$(KPROVE_FILE)/$(TEST_SYMBOLIC_BACKEND)
-
-tests/specs/%/timestamp: tests/specs/$$(firstword $$(subst /, ,$$*))/$$(KPROVE_FILE).$$(KPROVE_EXT)
- $(POETRY_RUN) kevm-pyk kompile-spec \
- $< \
- --target $(word 3, $(subst /, , $*)) \
- --output-definition tests/specs/$(firstword $(subst /, ,$*))/$(KPROVE_FILE)/$(word 3, $(subst /, , $*)) \
- --main-module $(KPROVE_MODULE) \
- --syntax-module $(KPROVE_MODULE) \
- $(KOMPILE_OPTS)
-
-prove_smoke_tests := $(shell cat tests/specs/smoke)
-
-.PHONY: test-prove-smoke
-test-prove-smoke: $(prove_smoke_tests:=.prove)
-
-
-# Interactive Tests
-
-TEST_CONCRETE_BACKEND := llvm
-
-KEVM_MODE := NORMAL
-KEVM_SCHEDULE := SHANGHAI
-KEVM_CHAINID := 1
-
-KRUN_OPTS ?=
-
-KEEP_OUTPUTS := false
-CHECK := git --no-pager diff --no-index --ignore-all-space -R
-
-tests/ethereum-tests/LegacyTests/Constantinople/VMTests/%: KEVM_MODE = VMTESTS
-tests/ethereum-tests/LegacyTests/Constantinople/VMTests/%: KEVM_SCHEDULE = DEFAULT
-
-tests/%.run-interactive: tests/%
- $(POETRY_RUN) kevm-pyk run $< $(KEVM_OPTS) $(KRUN_OPTS) --target $(TEST_CONCRETE_BACKEND) \
- --mode $(KEVM_MODE) --schedule $(KEVM_SCHEDULE) --chainid $(KEVM_CHAINID) \
- > tests/$*.$(TEST_CONCRETE_BACKEND)-out \
- || $(CHECK) tests/$*.$(TEST_CONCRETE_BACKEND)-out tests/templates/output-success-$(TEST_CONCRETE_BACKEND).json
- $(KEEP_OUTPUTS) || rm -rf tests/$*.$(TEST_CONCRETE_BACKEND)-out
-
-interactive_tests = tests/ethereum-tests/LegacyTests/Constantinople/VMTests/vmArithmeticTest/add0.json \
- tests/ethereum-tests/LegacyTests/Constantinople/VMTests/vmIOandFlowOperations/pop1.json \
- tests/interactive/sumTo10.evm
-
-.PHONY: test-interactive
-test-interactive: $(interactive_tests:=.run-interactive)
-
-
-# Media
-# -----
-
-media: media-pdf
-
-### Media generated PDFs
-
-.PHONY: media_pdfs
-media_pdfs := 201710-presentation-devcon3 \
- 201801-presentation-csf \
- 201905-exercise-k-workshop \
- 201908-trufflecon-workshop 201908-trufflecon-firefly
-
-media/%.pdf: media/%.md media/citations.md
- @mkdir -p $(dir $@)
- cat $^ | pandoc --from markdown --filter pandoc-citeproc --to beamer --output $@
-
-.PHONY: media-pdf
-media-pdf: $(patsubst %, media/%.pdf, $(media_pdfs))
-
-.PHONY: metropolis-theme
-metropolis-theme: $(BUILD_DIR)/media/metropolis/beamerthememetropolis.sty
-
-$(BUILD_DIR)/media/metropolis/beamerthememetropolis.sty:
- cd $(dir $@) && $(MAKE)
diff --git a/README.md b/README.md
deleted file mode 100644
index 6ab0976f05..0000000000
--- a/README.md
+++ /dev/null
@@ -1,408 +0,0 @@
-KEVM: Semantics of EVM in K
-===========================
-
-In this repository, we provide a model of the EVM in K.
-
-Fast Installation
------------------
-
-- `bash <(curl https://kframework.org/install)`: install [kup package manager].
-- `kup install kevm`: install KEVM.
-- `kup list kevm`: list available KEVM versions.
-- `kup update kevm`: update to latest KEVM version.
-
-**NOTE**: The first run will take longer to fetch all the libraries and compile sources. (30m to 1h)
-
-Documentation/Support
----------------------
-
-These may be useful for learning KEVM and K (newest to oldest):
-
-- [K, KEVM and Foundry Integration overview](https://www.youtube.com/watch?v=9PLnQStkiUo)
-- [Jello Paper], a nice presentation of this repository.
-- [20 minute tour of the semantics](https://www.youtube.com/watch?v=tIq_xECoicQNov) at [2017 Devcon3].
-- [KEVM 1.0 technical report](http://hdl.handle.net/2142/97207), especially sections 3 and 5.
-- [KEVM Paper at CSF'18/FLoC](https://fsl.cs.illinois.edu/publications/hildenbrandt-saxena-zhu-rodrigues-daian-guth-moore-zhang-park-rosu-2018-csf).
-
-To get support for KEVM, please join our [Discord Channel](https://discord.com/invite/CurfmXNtbN).
-
-If you want to start proving with KEVM, refer to [VERIFICATION.md].
-
-Repository Structure
---------------------
-
-The following files constitute the KEVM semantics:
-
-- [network.md](kevm-pyk/src/kevm_pyk/kproj/evm-semantics/network.md) provides the status codes reported to an Ethereum client on execution exceptions.
-- [json-rpc.md](kevm-pyk/src/kevm_pyk/kproj/evm-semantics/json-rpc.md) is an implementation of JSON RPC in K.
-- [evm-types.md](kevm-pyk/src/kevm_pyk/kproj/evm-semantics/evm-types.md) provides the (functional) data of EVM (256-bit words, wordstacks, etc...).
-- [serialization.md](kevm-pyk/src/kevm_pyk/kproj/evm-semantics/serialization.md) provides helpers for parsing and unparsing data (hex strings, recursive-length prefix, Merkle trees, etc.).
-- [evm.md](kevm-pyk/src/kevm_pyk/kproj/evm-semantics/evm.md) is the main KEVM semantics, containing EVM’s configuration and transition rules.
-- [gas.md](kevm-pyk/src/kevm_pyk/kproj/evm-semantics/gas.md) contains all information relevant to gas.
-- [schedule.md](kevm-pyk/src/kevm_pyk/kproj/evm-semantics/schedule.md) contains all information relevant to EVM schedules.
-
-These additional files extend the semantics to make the repository more useful:
-
-- [buf.md](kevm-pyk/src/kevm_pyk/kproj/evm-semantics/buf.md) defines the `#buf` byte-buffer abstraction for use during symbolic execution.
-- [abi.md](kevm-pyk/src/kevm_pyk/kproj/evm-semantics/abi.md) defines the [Contract ABI Specification](https://docs.soliditylang.org/en/v0.8.22/abi-spec.html) for use in proofs and easy contract/function specification.
-- [hashed-locations.md](kevm-pyk/src/kevm_pyk/kproj/evm-semantics/hashed-locations.md) defines the `#hashedLocation` abstraction used to specify Solidity-generated storage layouts.
-- [edsl.md](kevm-pyk/src/kevm_pyk/kproj/evm-semantics/edsl.md) combines the previous three abstractions for ease-of-use.
-
-These files are used for testing the semantics itself:
-
-- [state-utils.md](kevm-pyk/src/kevm_pyk/kproj/evm-semantics/state-utils.md) provides functionality for EVM initialization, setup, and querying.
-- [driver.md](kevm-pyk/src/kevm_pyk/kproj/evm-semantics/driver.md) is an execution harness for KEVM, providing a simple language for describing tests/programs.
-
-Building from source
---------------------
-
-There are two backends of K available: LLVM for concrete execution and Haskell for symbolic execution.
-This repository generates the build-products for each backend in `$XDG_CACHE_HOME/evm-semantics-`.
-
-### System Dependencies
-
-First install the following tools:
-
-- [git](https://git-scm.com/)
-- GNU [Bison](https://www.gnu.org/software/bison/), [Flex](https://github.com/westes/flex), and [Autoconf](http://www.gnu.org/software/autoconf/).
-- GNU [libmpfr](https://www.mpfr.org/) and [libtool](https://www.gnu.org/software/libtool/).
-- [Z3](https://github.com/Z3Prover/z3) version 4.12.1
-
-#### Installing Z3
-
-KEVM requires Z3 version 4.12.1, which you may need to install from a source build if your package manager supplies a different version.
-To do so, follow the instructions [here](https://github.com/Z3Prover/z3#building-z3-using-make-and-gccclang) after checking out the correct tag in the Z3 repository:
-
-```sh
-git clone https://github.com/Z3Prover/z3.git
-cd z3
-git checkout z3-4.12.1
-python scripts/mk_make.py
-cd build
-make
-sudo make install
-```
-
-On macOS, it is easiest to install Z3 from Homebrew.
-If you wish to install from the source, install it to an appropriate prefix (e.g. `/usr/local` on Intel machines).
-
-#### Ubuntu
-
-On Ubuntu >= 22.04 (for example):
-
-```sh
-sudo apt-get install --yes \
- autoconf bison clang-12 cmake curl flex gcc jq libboost-test-dev \
- libcrypto++-dev libffi-dev libgflags-dev libjemalloc-dev libmpfr-dev \
- libprocps-dev libsecp256k1-dev libssl-dev libtool libyaml-dev lld-12 \
- llvm-12-tools make maven openjdk-11-jdk pkg-config python3 python3-dev \
- python3-pip rapidjson-dev time zlib1g-dev libfmt-dev
-```
-
-On Ubuntu < 18.04, you'll need to skip `libsecp256k1-dev` and instead build it from source (via our `Makefile`):
-
-```sh
-make libsecp256k1
-```
-
-#### Arch Linux
-
-On ArchLinux:
-
-```sh
-sudo pacman -S \
- base base-devel boost clang cmake crypto++ curl git gmp \
- gflags jdk-openjdk jemalloc libsecp256k1 lld llvm maven \
- mpfr poetry python stack yaml-cpp zlib
-```
-
-#### macOS
-
-After installing the Command Line Tools, [Homebrew](https://brew.sh/), and getting the [blockchain plugin](#blockchain-plugin), run:
-
-```sh
-brew tap runtimeverification/k
-brew install java automake libtool gmp mpfr pkg-config maven libffi llvm@14 openssl python bash runtimeverification/k/cryptopp@8.6.0 poetry solidity
-make libsecp256k1
-```
-
-**NOTE**: It is recommended to use the homebrew version of `flex` and XCode.
-
-If you are building on an Apple Silicon machine, ensure that your `PATH` is set up correctly before running `make deps` or `make k-deps`.
-You can do so using [`direnv`](https://direnv.net/) by copying `macos-envrc` to `.envrc`, then running `direnv allow`.
-
-If the build on macOS still fails, you can also try adding the following lines to the top of your `Makefile` under `UNAME_S`:
-
-```sh
-ifeq ($(UNAME_S), Darwin)
-SHELL := /usr/local/bin/bash
-PATH := $(pwd)/.build/usr/bin:$(PATH)
-endif
-```
-
-#### Haskell Stack (all platforms)
-
-- [Haskell Stack](https://docs.haskellstack.org/en/stable/install_and_upgrade/#installupgrade).
- Note that the version of the `stack` tool provided by your package manager might not be recent enough.
- Please follow installation instructions from the Haskell Stack website linked above.
-
-To upgrade `stack` (if needed):
-
-```sh
-stack upgrade
-export PATH=$HOME/.local/bin:$PATH
-```
-
-### Build Dependencies
-
-#### K Framework
-
-You need to install the [K Framework] on your system, see the instructions there.
-The fastest way is via the [kup package manager], with which you can do to get the correct version of K:
-
-```sh
-kup install k.openssl.procps --version v$(cat deps/k_release)
-```
-
-You can also drop into a single development shell with the correct version of K on path by doing:
-
-```sh
-kup shell k.openssl.procps --version v$(cat deps/k_release)
-```
-
-### Building
-
-First you need to set up a virtual environment using Poetry with the prerequisites `python 3.8.*`, `pip >= 20.0.2`, `poetry >= 1.3.2`:
-
-```sh
-make poetry
-```
-
-#### Blockchain Plugin
-
-You also need to get the blockchain plugin submodule and install it.
-
-```sh
-git submodule update --init --recursive
-poetry -C kevm-pyk run kdist --verbose build evm-semantics.plugin
-```
-
-To change the default compiler:
-
-```sh
-CXX=clang++-14 poetry -C kevm-pyk run kdist --verbose build evm-semantics.plugin
-```
-
-On Apple silicon:
-
-```sh
-APPLE_SILICON=true poetry -C kevm-pyk run kdist --verbose build evm-semantics.plugin
-```
-
-#### K Definitions
-
-Finally, you can build the semantics.
-
-```sh
-poetry -C kevm-pyk run kdist --verbose build -j4
-```
-
-You can build specific targets using options `evm-semantics.{llvm,haskell,haskell-standalone,plugin}`, e.g.:
-
-```sh
-poetry -C kevm-pyk run kdist build -j2 evm-semantics.llvm evm-semantics.haskell
-```
-
-Targets can be cleaned with
-
-```sh
-poetry -C kevm-pyk run kdist clean
-```
-
-For more information, refer to `kdist --help` and the [dist.py](kevm-pyk/src/kevm_pyk/dist.py) module.
-
-Running Tests
--------------
-
-To execute tests from the [Ethereum Test Set], the submodule needs to be fetched first.
-
-```sh
-git submodule update --init --recursive -- tests/ethereum-tests
-```
-
-The tests are run using the supplied `Makefile`.
-
-The following subsume all other tests:
-
-- `make test`: All of the quick tests.
-- `make test-all`: All of the quick and slow tests.
-
-These are the individual test-suites (all of these can be suffixed with `-all` to also run slow tests):
-
-- `make test-vm`: VMTests from the [Ethereum Test Set].
-- `make test-bchain`: Subset of BlockchainTests from the [Ethereum Test Set].
-- `make test-proof`: Proofs from the [Verified Smart Contracts].
-- `make test-interactive`: Tests of the `kevm` command.
-
-All these targets call `pytest` under the hood. You can pass additional arguments to the call by appending them to variable `PYTEST_ARGS`. E.g. run
-
-```
-make test-vm PYTEST_ARGS+=-vv
-```
-
-to execute VMTests with increased verbosity, and
-
-```
-make test-vm PYTEST_ARGS+=-n0
-```
-
-to execute them on a single worker.
-
-Files produced by test runs, e.g. kompiled definition and logs, can be found in `/tmp/pytest-of-/`.
-
-For Developers
---------------
-
-If built from the source, the `kevm-pyk` executable will be installed in a virtual environemtn handled by Poetry.
-You can call `kevm-pyk --help` to get a quick summary of how to use the script.
-
-Run the file `tests/ethereum-tests/LegacyTests/Constantinople/VMTests/vmArithmeticTest/add0.json`:
-
-```sh
-poetry -C kevm-pyk run kevm-pyk run tests/ethereum-tests/LegacyTests/Constantinople/VMTests/vmArithmeticTest/add0.json --schedule DEFAULT --mode VMTESTS
-```
-
-To enable the debug symbols for the llvm backend, build using this command:
-
-```sh
-poetry -C kevm-pyk run kdist build evm-semantics.llvm --arg enable-llvm-debug=true
-```
-
-To debug a conformance test, add the `--debugger` flag to the command:
-
-```sh
-poetry -C kevm-pyk run kevm-pyk run tests/ethereum-tests/BlockchainTests/GeneralStateTests/stExample/add11.json --target llvm --mode NORMAL --schedule SHANGHAI --chainid 1 --debugger
-```
-
-### Keeping in mind while developing
-
-Always have your build up-to-date.
-
-- If using the kup package manager, run `kup install kevm --version .` to install the local version.
-- If building from source:
- - `make poetry` needs to be re-run if you touch any of the `kevm-pyk` code.
- - `poetry -C kevm-pyk run kdist build --force` needs to be re-run if you touch any of this repos files.
- - `poetry -C kevm-pyk run kdist clean` is a safe way to remove the target directory
-
-### Building with Nix
-
-We now support building KEVM using [nix flakes](https://nixos.wiki/wiki/Flakes).
-To set up nix flakes you will need to be on `nix` 2.4 or higher and follow the instructions [here](https://nixos.wiki/wiki/Flakes).
-
-For example, if you are on a standard Linux distribution, such as Ubuntu, first [install nix](https://nixos.org/download.html#download-nix)
-and then enable flakes by editing either `~/.config/nix/nix.conf` or `/etc/nix/nix.conf` and adding:
-
-```
-experimental-features = nix-command flakes
-```
-
-This is needed to expose the Nix 2.0 CLI and flakes support that are hidden behind feature-flags.
-
-By default, Nix will build the project and its transitive dependencies from source, which can take up to an hour.
-We recommend setting up [the binary cache](https://app.cachix.org/cache/kore) to speed up the build process significantly.
-
-To build KEVM, run:
-
-```sh
-nix build .#kevm
-```
-
-This will build all of KEVM and K and put a link to the resulting binaries in the `result/` folder.
-
-
-**NOTE**: Mac users, especially those running M1/M2 Macs may find nix segfaulting on occasion. If this happens, try running the nix command like this: `GC_DONT_GC=1 nix build .`
-
-If you want to temporarily add the `kevm` binary to the current shell, run
-
-```sh
-nix shell .#kevm
-```
-
-### Profiling with Nix
-
-Nix can also be used to quickly profile different versions of the Haskell backend. Simply run:
-
-```sh
-nix build github:runtimeverification/evm-semantics#profile \
- --override-input k-framework/haskell-backend github:runtimeverification/haskell-backend/ \
- -o prof-
-```
-
-replacing `` with the commit you want to run profiling against.
-
-If you want to profile against a working version of the Haskell backend repository, simply `cd` into the root of the repo and run:
-
-```sh
-nix build github:runtimeverification/evm-semantics#profile \
- --override-input k-framework/haskell-backend $(pwd) \
- -o prof-my-feature
-```
-
-To compare profiles, you can use:
-
-```sh
-nix run github:runtimeverification/evm-semantics#compare-profiles -- prof-my-feature prof-
-```
-
-This will produce a nice table with the times for both versions of the haskell-backend.
-Note that `#profile` pre-pends the output of `kore-exec --version` to the profile run, which is then used as a tag by the `#compare-profiles` script.
-Therefore, any profiled local checkout of the haskell-backend will report as `dirty-ghc8107` in the resulting table.
-
-Media
------
-
-This repository can build two pieces of documentation for you, the [Jello Paper] and the [2017 Devcon3] presentation.
-
-### System Dependencies
-
-For the presentations in the `media` directory, you'll need `pdflatex`, commonly provided with `texlive-full`, and `pandoc`.
-
-```sh
-sudo apt install texlive-full pandoc
-```
-
-### Building
-
-To build all the PDFs (presentations and reports) available in the `media/` directory, use:
-
-```sh
-make media
-```
-
-Resources
-=========
-
-- [EVM Yellowpaper](https://github.com/ethereum/yellowpaper): Original specification of EVM.
-- [LEM Semantics of EVM](https://github.com/pirapira/eth-isabelle)
-- [EVM Opcode Interactive Reference](https://www.evm.codes/?fork=merge)
-- [Solidity ABI Encoding](https://docs.soliditylang.org/en/v0.8.22/abi-spec.html)
-
-For more information about the [K Framework], refer to these sources:
-
-- [The K Tutorial](https://github.com/runtimeverification/k/tree/master/k-distribution/k-tutorial)
-- [Semantics-Based Program Verifiers for All Languages](https://fsl.cs.illinois.edu/publications/stefanescu-park-yuwen-li-rosu-2016-oopsla)
-- [Reachability Logic Resources](http://fsl.cs.illinois.edu/index.php/Reachability_Logic_in_K)
-- [Matching Logic Resources](http://www.matching-logic.org/)
-- [Logical Frameworks](https://dl.acm.org/doi/10.5555/208683.208700): Discussion of logical frameworks.
-
-[K Framework]:
-[Jello Paper]:
-[2017 Devcon3]:
-[K Reachability Logic Prover]:
-[K Editor Support]:
-[Ethereum Test Set]:
-[Verified Smart Contracts]:
-[eDSL]:
-[kup package manager]:
-[Makefile]: <./Makefile>
-[VERIFICATION.md]: <./VERIFICATION.md>
diff --git a/VERIFICATION.md b/VERIFICATION.md
deleted file mode 100644
index 8b829ec6b6..0000000000
--- a/VERIFICATION.md
+++ /dev/null
@@ -1,112 +0,0 @@
-Verification Instructions for KEVM
-==================================
-
-We assume that KEVM is installed, and the [K tutorial] has been completed.
-This document provides instructions for kompiling and running claims using KEVM.
-
-In `tests/specs/examples`, you can find a few examples to get you started on proving with kevm.
-
-Example 1: Sum to N
--------------------
-
-Have a look at the [sum-to-n-spec.k] file.
-It has two modules:
-
- - `VERIFICATION` - containing the EVM program and a few `simplification` rules.
- - `SUM-TO-N-SPEC` - containing the claims which will be executed.
-
-The first step is kompiling the `.k` file with the below command.
-
-```sh
-kevm kompile-spec sum-to-n-spec.k --target haskell --syntax-module VERIFICATION --main-module VERIFICATION --definition sum-to-n-spec/haskell
-```
-
-In this example, the arguments used are:
-
- - `--target haskell`: specify which symbolic backend to use for reasoning.
- - `--syntax-module VERIFICATION`: explicitly state the syntax module.
- - `--main-module VERIFICATION`: explicitly state the main module.
- - `--definition sum-to-n-spec/haskell`: the path where the kompiled definition is stored.
-
-Next, run the prover with:
-
-```sh
-kevm prove sum-to-n-spec.k --definition sum-to-n-spec/haskell
-```
-
-The expected output is `#Top` which represents that all the claims have been proven.
-
-Example 2: Faulty ERC20
------------------------
-
-This example will describe the process of running claims for an ERC20 contract.
-Have a look at [erc20-spec.md].
-It contains claims for a few basic ERC20 properties and the helper modules required to run the proofs.
-The ERC20 Solidity contract that is tested is [ERC20.sol].
-
-In this example, we rely on a helper module, `ERC20-VERIFICATION`, which must be generated from the [ERC20.sol] Solidity contract.
-The module is generated using the following `solc-to-k` command.
-
-```sh
-kevm solc-to-k ERC20.sol ERC20 --main-module ERC20-VERIFICATION > erc20-bin-runtime.k
-```
-
-- `solc-to-k` will parse a Solidity contract and generate a helper K module.
-- `--main-module` is used to set the name of the module.
-
-The generated `erc20-bin-runtime.k` file contains K rules and productions for the contract’s bytecode, storage indexes for the state variables, and function selectors, among others.
-These rules are then used in the claims. As an example, the `#binRuntime(ERC20)` production, which is found in the `` cell, will rewrite to `#parseByteStack (contractBytecode)`, parsing the hexadecimal string into a `ByteStack`.
-
-Following this, we can compile the Markdown file with:
-
-```sh
-kevm kompile-spec erc20-spec.md --syntax-module VERIFICATION --main-module VERIFICATION --definition erc20-spec/haskell
-```
-
-Next, run the prover with:
-
-```sh
-kevm prove erc20-spec.md --definition erc20-spec/haskell --claim ERC20-SPEC.decimals
-```
-
-Here, `--claim` tells the prover to run only the `decimals` spec from the `ERC20-SPEC` module.
-
-More to know
-------------
-
-To prove one of the specifications:
-
-```sh
-kevm prove tests/specs/erc20/ds/transfer-failure-1-a-spec.k --definition tests/specs/erc20/verification/haskell
-```
-
-You can also debug proofs interactively:
-
-```sh
-kevm prove tests/specs/erc20/ds/transfer-failure-1-a-spec.k --definition tests/specs/erc20/verification/haskell --debugger
-```
-
-In addition to this, you can use `kevm show-kcfg ...` or `kevm view-kcfg ...` to get a visualization.
-
-`kevm view-kcfg [spec_file] [--save-directory save_directory] [--claim claim_label] ...` command takes the same basic arguments as `kevm prove ...` does, including:
- - `spec_file` is the file to look in for specifications. This file is read like with `kevm prove —pyk …`; the `KProve.get_claims` invokes the frontend.
- - `--save_directory` must be passed as where the KCFGs have been saved (by a previous call to `kevm prove --save-directory save_directory ...`
- - `--claim claim_label` option is added, but unlike the `kevm prove ...`, you can only repeat it once. This option lets you select an individual claim out of the `spec_file`; if not supplied, it’s assumed that only one spec is present.
- - `--spec-module spec_module` is also an inherited option.
-
-The interactive KCFG (`view-kcfg`) puts your terminal in *application mode*. To select text in this mode, hold the modifier key provided by your terminal emulator (typically SHIFT or OPTION) while clicking and dragging. Refer to the [Textualize documentation](https://github.com/Textualize/textual/blob/main/FAQ.md#how-can-i-select-and-copy-text-in-a-textual-app) for more information.
-
-A running example:
-
-```sh
-mkdir kcfgs
-kevm kompile-spec tests/specs/benchmarks/verification.k --definition tests/specs/benchmarks/verification/haskell --main-module VERIFICATION --syntax-module VERIFICATION
-kevm prove tests/specs/benchmarks/address00-spec.k --definition tests/specs/benchmarks/verification/haskell --verbose --save-directory kcfgs
-kevm view-kcfg --verbose kcfgs tests/specs/benchmarks/address00-spec.k --definition tests/specs/benchmarks/verification/haskell
-```
-
-[sum-to-n-spec.k]: <./tests/specs/examples/sum-to-n-spec.k>
-[erc20-spec.md]: <./tests/specs/examples/erc20-spec.md>
-[ERC20.sol]: <./tests/specs/examples/ERC20.sol>
-[K tutorial]:
-[more about it here]:
diff --git a/VERIFICATION/index.html b/VERIFICATION/index.html
new file mode 100644
index 0000000000..51c9295980
--- /dev/null
+++ b/VERIFICATION/index.html
@@ -0,0 +1,281 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+KEVM: Semantics of EVM in K | Runtime Verification, Inc.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ EVM Semantics
+
We assume that KEVM is installed, and the K tutorial has been completed.
+This document provides instructions for kompiling and running claims using KEVM.
+
In tests/specs/examples, you can find a few examples to get you started on proving with kevm.
+
Example 1: Sum to N
+
Have a look at the sum-to-n-spec.k file.
+It has two modules:
+
+
VERIFICATION - containing the EVM program and a few simplification rules.
+
SUM-TO-N-SPEC - containing the claims which will be executed.
+
+
The first step is kompiling the .k file with the below command.
The expected output is #Top which represents that all the claims have been proven.
+
Example 2: Faulty ERC20
+
This example will describe the process of running claims for an ERC20 contract.
+Have a look at erc20-spec.md.
+It contains claims for a few basic ERC20 properties and the helper modules required to run the proofs.
+The ERC20 Solidity contract that is tested is ERC20.sol.
+
In this example, we rely on a helper module, ERC20-VERIFICATION, which must be generated from the ERC20.sol Solidity contract.
+The module is generated using the following solc-to-k command.
solc-to-k will parse a Solidity contract and generate a helper K module.
+
--main-module is used to set the name of the module.
+
+
The generated erc20-bin-runtime.k file contains K rules and productions for the contract’s bytecode, storage indexes for the state variables, and function selectors, among others.
+These rules are then used in the claims. As an example, the #binRuntime(ERC20) production, which is found in the <program> cell, will rewrite to #parseByteStack (contractBytecode), parsing the hexadecimal string into a ByteStack.
+
Following this, we can compile the Markdown file with:
In addition to this, you can use kevm show-kcfg ... or kevm view-kcfg ... to get a visualization.
+
kevm view-kcfg [spec_file] [--save-directory save_directory] [--claim claim_label] ... command takes the same basic arguments as kevm prove ... does, including:
+
+
spec_file is the file to look in for specifications. This file is read like with kevm prove —pyk …; the KProve.get_claims invokes the frontend.
+
--save_directory must be passed as where the KCFGs have been saved (by a previous call to kevm prove --save-directory save_directory ...
+
--claim claim_label option is added, but unlike the kevm prove ..., you can only repeat it once. This option lets you select an individual claim out of the spec_file; if not supplied, it’s assumed that only one spec is present.
+
--spec-module spec_module is also an inherited option.
+
+
The interactive KCFG (view-kcfg) puts your terminal in application mode. To select text in this mode, hold the modifier key provided by your terminal emulator (typically SHIFT or OPTION) while clicking and dragging. Refer to the Textualize documentation for more information.