From 92b87773274307dcf388326c92b35bc168c04a79 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Wed, 4 Mar 2026 15:22:11 +0100
Subject: [PATCH 01/77] add eldarica to classpath

This is most certainly not the intended way, the `ivy.xml` adds multiple repository. But good enough for now until eldarica is published to https://www.sosy-lab.org/ivy/uuverifiers/
---
 .classpath            |  1 +
 .idea/JavaSMT.iml     |  1 +
 build.xml             |  3 ++-
 build/ivysettings.xml | 17 +++++++++++------
 lib/ivy.xml           |  4 ++++
 5 files changed, 19 insertions(+), 7 deletions(-)

diff --git a/.classpath b/.classpath
index 06e8af411e..1ce22f8001 100644
--- a/.classpath
+++ b/.classpath
@@ -24,6 +24,7 @@ SPDX-License-Identifier: Apache-2.0
 	<classpathentry kind="lib" path="lib/java/build/error_prone_annotations.jar" sourcepath="lib/java-contrib/error_prone_annotations-sources.jar"/>
 	<classpathentry kind="lib" path="lib/java/core/common.jar" sourcepath="lib/java-contrib/common-sources.jar"/>
 	<classpathentry kind="lib" path="lib/java/runtime-smtinterpol/smtinterpol.jar" sourcepath="lib/java-contrib/smtinterpol-sources.jar"/>
+	<classpathentry kind="lib" path="lib/java/runtime-eldarica/eldarica_2.13.jar" sourcepath="lib/java-contrib/eldarica_2.13-sources.jar"/>
 	<classpathentry kind="lib" path="lib/java/runtime-princess/princess_2.13.jar" sourcepath="lib/java-contrib/princess_2.13-sources.jar"/>
 	<classpathentry kind="lib" path="lib/java/runtime-princess/scala-library.jar"/>
 	<classpathentry kind="lib" path="lib/java/runtime-princess/princess-smt-parser_2.13.jar"/>
diff --git a/.idea/JavaSMT.iml b/.idea/JavaSMT.iml
index 77b8b55e62..bb237d5c8c 100644
--- a/.idea/JavaSMT.iml
+++ b/.idea/JavaSMT.iml
@@ -367,6 +367,7 @@ SPDX-License-Identifier: Apache-2.0
         <SOURCES />
       </library>
     </orderEntry>
+    <orderEntry type="library" name="runtime-eldarica" level="project" />
   </component>
   <component name="org.twodividedbyzero.idea.findbugs">
     <option name="_basePreferences">
diff --git a/build.xml b/build.xml
index 47fdf4770a..4ab9d31a4c 100644
--- a/build.xml
+++ b/build.xml
@@ -26,6 +26,7 @@ SPDX-License-Identifier: Apache-2.0
         runtime-boolector,
         runtime-cvc4,
         runtime-cvc5,
+        runtime-eldarica,
         runtime-mathsat,
         runtime-opensmt,
         runtime-optimathsat,
@@ -49,7 +50,7 @@ SPDX-License-Identifier: Apache-2.0
     <property name="errorprone.options" value="-Xep:Finally:OFF -Xep:MissingSummary:OFF -Xep:UnescapedEntity:OFF"/>
 
     <!-- Maven Central metadata -->
-    <property name="ivy.pom.description" value="Unified acccess layer to SMT solvers"/>
+    <property name="ivy.pom.description" value="Unified access layer to SMT solvers"/>
     <property name="ivy.pom.url" value="https://github.com/sosy-lab/java-smt"/>
     <property name="ivy.pom.name" value="java-smt"/>
     <property name="ivy.pom.groupId" value="org.sosy-lab"/>
diff --git a/build/ivysettings.xml b/build/ivysettings.xml
index dcec9e40e1..4833706668 100644
--- a/build/ivysettings.xml
+++ b/build/ivysettings.xml
@@ -15,14 +15,19 @@ SPDX-License-Identifier: Apache-2.0
          Keep this file synchronized with
          https://gitlab.com/sosy-lab/software/java-project-template
     -->
-    <settings defaultResolver="Sosy-Lab"/>
+    <settings defaultResolver="chain"/>
     <property name="repo.dir" value="${basedir}/repository"/>
     <resolvers>
-        <!-- Resolver for downloading dependencies -->
-        <url name="Sosy-Lab" descriptor="required">
-            <ivy pattern="${ivy.repo.url}/[organisation]/[module]/ivy-[revision].xml" />
-            <artifact pattern="${ivy.repo.url}/[organisation]/[module]/([arch]/)[artifact]-[revision](-[classifier]).[ext]" />
-        </url>
+        <chain name="chain">
+            <!-- Resolver for downloading dependencies -->
+            <url name="Sosy-Lab" descriptor="required">
+                <ivy pattern="${ivy.repo.url}/[organisation]/[module]/ivy-[revision].xml" />
+                <artifact pattern="${ivy.repo.url}/[organisation]/[module]/([arch]/)[artifact]-[revision](-[classifier]).[ext]" />
+            </url>
+
+            <ibiblio name="local" m2compatible="true" root="https://eldarica.org/maven/"/>
+            <ibiblio name="local" m2compatible="true" root="https://repo1.maven.org/maven2/"/>
+        </chain>
 
         <!-- Resolver for publishing this project -->
         <filesystem name="Sosy-Lab-Publish">
diff --git a/lib/ivy.xml b/lib/ivy.xml
index 61d1d919b6..ba13aa6828 100644
--- a/lib/ivy.xml
+++ b/lib/ivy.xml
@@ -40,6 +40,7 @@ SPDX-License-Identifier: Apache-2.0
         <conf name="runtime-optimathsat" extends="core" description="only one solver included"/>
         <conf name="runtime-smtinterpol" extends="core" description="only one solver included"/>
         <conf name="runtime-princess" extends="core" description="only one solver included"/>
+        <conf name="runtime-eldarica" extends="core" description="only one solver included"/>
         <conf name="runtime-princess-with-javacup" extends="core" description="only one solver included"/>
         <conf name="runtime-z3" extends="runtime-z3-x64,runtime-z3-arm64" description="only one solver included"/>
         <conf name="runtime-z3-x64" extends="core" description="only one solver included"/>
@@ -172,6 +173,9 @@ SPDX-License-Identifier: Apache-2.0
         <!-- SmtInterpol -->
         <dependency org="de.uni-freiburg.informatik.ultimate" name="smtinterpol" rev="2.5-1242-g5c50fb6d" conf="runtime-smtinterpol->master; contrib->sources"/>
 
+        <!-- Eldarica -->
+        <dependency org="uuverifiers" name="eldarica_2.13" rev="2.2.1" conf="runtime-eldarica->master; contrib->sources"/>
+
         <!-- Princess and Ostrich for our Maven release -->
         <dependency org="io.github.uuverifiers" name="princess_2.13" rev="2025-11-17" conf="runtime-princess-with-javacup->default; contrib->sources"/>
         <dependency org="io.github.uuverifiers" name="ostrich_2.13" rev="2.0" conf="runtime-princess-with-javacup->default; contrib->sources"/>

From 0d749c9f4fa8749e1284552c2de46c5b7272ed16 Mon Sep 17 00:00:00 2001
From: gcarpio21 <gabriel.carpio.99@gmail.com>
Date: Sat, 14 Mar 2026 04:02:48 +0000
Subject: [PATCH 02/77] Cmdline: Added `JavaSMTMain` class, main entry point
 for the cmdline interface.

---
 .../java_smt/cmdline/JavaSMTMain.java         | 180 ++++++++++++++++++
 1 file changed, 180 insertions(+)
 create mode 100644 src/org/sosy_lab/java_smt/cmdline/JavaSMTMain.java

diff --git a/src/org/sosy_lab/java_smt/cmdline/JavaSMTMain.java b/src/org/sosy_lab/java_smt/cmdline/JavaSMTMain.java
new file mode 100644
index 0000000000..c5c58facd0
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/cmdline/JavaSMTMain.java
@@ -0,0 +1,180 @@
+/*
+ * This file is part of JavaSMT,
+ * an API wrapper for a collection of SMT solvers:
+ * https://github.com/sosy-lab/java-smt
+ *
+ * SPDX-FileCopyrightText: 2026 Dirk Beyer <https://www.sosy-lab.org>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.sosy_lab.java_smt.cmdline;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableMap;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.logging.Level;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.sosy_lab.common.ShutdownManager;
+import org.sosy_lab.common.ShutdownNotifier;
+import org.sosy_lab.common.annotations.SuppressForbidden;
+import org.sosy_lab.common.configuration.Configuration;
+import org.sosy_lab.common.configuration.ConfigurationBuilder;
+import org.sosy_lab.common.configuration.InvalidConfigurationException;
+import org.sosy_lab.common.configuration.Option;
+import org.sosy_lab.common.configuration.Options;
+import org.sosy_lab.common.log.BasicLogManager;
+import org.sosy_lab.common.log.LogManager;
+import org.sosy_lab.java_smt.SolverContextFactory;
+import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
+import org.sosy_lab.java_smt.api.BooleanFormula;
+import org.sosy_lab.java_smt.api.FormulaManager;
+import org.sosy_lab.java_smt.api.ProverEnvironment;
+import org.sosy_lab.java_smt.api.SolverContext;
+import org.sosy_lab.java_smt.api.SolverException;
+
+/**
+ * Main entry point for JavaSMT command-line interface. Executes SMT2 files using a selected solver
+ * and reports the result (sat/unsat/unknown).
+ */
+@SuppressForbidden("System.out in this class is ok")
+public class JavaSMTMain {
+
+  static final int ERROR_EXIT_CODE = 1;
+
+  /**
+   * Main method for running JavaSMT from command line.
+   *
+   * @param args Command-line arguments: [--solver SOLVER] [--logic LOGIC] file.smt2
+   */
+  @SuppressWarnings("resource") // We don't close LogManager
+  public static void main(String[] args) {
+    Locale.setDefault(Locale.US);
+
+    if (args.length == 0) {
+      args = new String[] {"--help"};
+    }
+
+    final Configuration config;
+    final LogManager logManager;
+    final MainOptions options;
+    final Map<String, String> cmdLineOptions;
+    try {
+      cmdLineOptions = CmdLineArguments.processArguments(args);
+      config = createConfiguration(cmdLineOptions);
+      logManager = BasicLogManager.create(config);
+      options = new MainOptions(config);
+
+      String logic = cmdLineOptions.get("solver.opensmt.logic");
+      String solver = cmdLineOptions.get("solver.solver");
+      if (logic != null && (solver == null || !solver.equals("OPENSMT"))) {
+        logManager.log(
+            Level.WARNING,
+            "Option --logic is only effective with OpenSMT solver, but solver is set to "
+                + (solver != null ? solver : "default")
+                + ". The logic setting will be ignored.");
+      }
+    } catch (InvalidCmdlineArgumentException e) {
+      throw Output.fatalError("Could not process command line arguments: %s", e.getMessage());
+    } catch (InvalidConfigurationException e) {
+      throw Output.fatalError("Invalid configuration: %s", e.getMessage());
+    }
+
+    if (options.smt2File == null) {
+      CmdLineArguments.printHelp(System.out);
+      System.exit(0);
+      return;
+    }
+
+    if (!Files.isReadable(Paths.get(options.smt2File))) {
+      throw Output.fatalError(
+          "Please provide a valid, readable SMT2 file: %s", options.smt2File);
+    }
+
+    run(config, logManager, options);
+  }
+
+  private static final ImmutableMap<String, String> EXTERN_OPTION_DEFAULTS =
+      ImmutableMap.of("log.level", Level.INFO.toString());
+
+  @VisibleForTesting
+  @Options
+  static final class MainOptions {
+
+    private MainOptions(Configuration config) throws InvalidConfigurationException {
+      config.inject(this);
+    }
+
+    @Option(secure = true, name = "smt2.file", description = "The SMT2 file to execute")
+    private @Nullable String smt2File = null;
+
+    @Option(secure = true, name = "solver.solver", description = "The SMT solver to use")
+    private Solvers solver = Solvers.SMTINTERPOL;
+  }
+
+  /**
+   * Creates a Configuration from command-line arguments.
+   *
+   * @param cmdLineOptions Processed command-line options map
+   * @return Configuration object for solver context
+   * @throws InvalidConfigurationException if configuration is invalid
+   */
+  @VisibleForTesting
+  public static Configuration createConfiguration(Map<String, String> cmdLineOptions)
+      throws InvalidConfigurationException {
+
+    ConfigurationBuilder configBuilder = Configuration.builder();
+    configBuilder.setOptions(EXTERN_OPTION_DEFAULTS);
+    configBuilder.setOptions(cmdLineOptions);
+
+    Configuration config = configBuilder.build();
+
+    return config;
+  }
+
+  private static void run(Configuration config, LogManager logManager, MainOptions options) {
+
+    String input;
+    try {
+      input = Files.readString(Paths.get(options.smt2File));
+    } catch (IOException e) {
+      throw Output.fatalError("Could not read SMT2 file: %s", e.getMessage());
+    }
+
+    ShutdownManager shutdownManager = ShutdownManager.create();
+    ShutdownNotifier notifier = shutdownManager.getNotifier();
+
+    try (SolverContext context =
+            SolverContextFactory.createSolverContext(config, logManager, notifier, options.solver);
+        ProverEnvironment prover = context.newProverEnvironment()) {
+
+      FormulaManager formulaManager = context.getFormulaManager();
+      List<BooleanFormula> formulas = formulaManager.parseAll(input);
+      for (BooleanFormula formula : formulas) {
+        prover.addConstraint(formula);
+      }
+
+      boolean isUnsat = prover.isUnsat();
+      System.out.println(isUnsat ? "unsat" : "sat");
+      System.exit(0);
+
+    } catch (InvalidConfigurationException e) {
+      throw Output.fatalError("Invalid configuration: %s", e.getMessage());
+    } catch (InterruptedException e) {
+      logManager.log(Level.WARNING, "SMT execution was interrupted.");
+      System.out.println("unknown");
+      System.exit(ERROR_EXIT_CODE);
+    } catch (SolverException e) {
+      logManager.logUserException(Level.SEVERE, e, "Error executing SMT2 solver");
+      System.out.println("unknown");
+      System.exit(ERROR_EXIT_CODE);
+    }
+  }
+
+  private JavaSMTMain() {}
+}

From 6d2edd41a4205eb9e22788b38728a6190fd7349e Mon Sep 17 00:00:00 2001
From: gcarpio21 <gabriel.carpio.99@gmail.com>
Date: Sat, 14 Mar 2026 04:10:13 +0000
Subject: [PATCH 03/77] Cmdline: Added `CmdLineArgument` class.

---
 .../java_smt/cmdline/CmdLineArgument.java     | 138 ++++++++++++++++++
 1 file changed, 138 insertions(+)
 create mode 100644 src/org/sosy_lab/java_smt/cmdline/CmdLineArgument.java

diff --git a/src/org/sosy_lab/java_smt/cmdline/CmdLineArgument.java b/src/org/sosy_lab/java_smt/cmdline/CmdLineArgument.java
new file mode 100644
index 0000000000..c600ad21cd
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/cmdline/CmdLineArgument.java
@@ -0,0 +1,138 @@
+/*
+ * This file is part of JavaSMT,
+ * an API wrapper for a collection of SMT solvers:
+ * https://github.com/sosy-lab/java-smt
+ *
+ * SPDX-FileCopyrightText: 2026 Dirk Beyer <https://www.sosy-lab.org>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.sosy_lab.java_smt.cmdline;
+
+import static com.google.common.base.Preconditions.checkState;
+import static org.sosy_lab.java_smt.cmdline.CmdLineArguments.putIfNotExistent;
+
+import com.google.common.base.Joiner;
+import com.google.common.collect.ImmutableSet;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Map.Entry;
+
+abstract class CmdLineArgument implements Comparable<CmdLineArgument> {
+
+  private final ImmutableSet<String> names;
+  private String description = "";
+
+  CmdLineArgument(String... pNames) {
+    names = ImmutableSet.copyOf(pNames);
+  }
+
+  @CanIgnoreReturnValue
+  CmdLineArgument withDescription(String pDescription) {
+    description = pDescription;
+    return this;
+  }
+
+  String getMainName() {
+    return names.iterator().next();
+  }
+
+  @Override
+  public int compareTo(CmdLineArgument other) {
+    return names.toString().compareTo(other.names.toString());
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    return o instanceof CmdLineArgument && names.equals(((CmdLineArgument) o).names);
+  }
+
+  @Override
+  public int hashCode() {
+    return names.hashCode();
+  }
+
+  @Override
+  public String toString() {
+    String s =
+        com.google.common.collect.FluentIterable.from(names)
+            .filter(arg -> !CmdLineArguments.isOldStyleArgument(arg))
+            .join(Joiner.on("/"));
+    if (description.isEmpty()) {
+      return s;
+    } else {
+      return String.format("%1$-20s %2$s", s, description);
+    }
+  }
+
+  boolean apply(Map<String, String> properties, String currentArg, Iterator<String> argsIt)
+      throws InvalidCmdlineArgumentException {
+    if (names.contains(currentArg)) {
+      apply0(properties, currentArg, argsIt);
+      return true;
+    }
+    return false;
+  }
+
+  abstract void apply0(Map<String, String> properties, String currentArg, Iterator<String> argsIt)
+      throws InvalidCmdlineArgumentException;
+
+  static class CmdLineArgument1 extends CmdLineArgument {
+
+    private String option;
+
+    CmdLineArgument1(String... pNames) {
+      super(pNames);
+    }
+
+    CmdLineArgument1 settingOption(String pOption) {
+      option = pOption;
+      return this;
+    }
+
+    @Override
+    final void apply0(Map<String, String> properties, String currentArg, Iterator<String> args)
+        throws InvalidCmdlineArgumentException {
+      if (args.hasNext()) {
+        handleArg(properties, currentArg, args.next());
+      } else {
+        throw new InvalidCmdlineArgumentException(currentArg + " argument missing.");
+      }
+    }
+
+    void handleArg(Map<String, String> pProperties, String pCurrentArg, String pArgValue)
+        throws InvalidCmdlineArgumentException {
+      checkState(option != null);
+      putIfNotExistent(pProperties, option, pArgValue);
+    }
+  }
+
+  static class PropertyAddingCmdLineArgument extends CmdLineArgument {
+
+    private final Map<String, String> additionalIfNotExistentArgs = new HashMap<>();
+
+    PropertyAddingCmdLineArgument(String... pNames) {
+      super(pNames);
+    }
+
+    @CanIgnoreReturnValue
+    PropertyAddingCmdLineArgument settingProperty(String pName, String pValue) {
+      additionalIfNotExistentArgs.put(pName, pValue);
+      return this;
+    }
+
+    @Override
+    void apply0(Map<String, String> properties, String currentArg, Iterator<String> args)
+        throws InvalidCmdlineArgumentException {
+      for (Entry<String, String> e : additionalIfNotExistentArgs.entrySet()) {
+        putIfNotExistent(properties, e.getKey(), e.getValue());
+      }
+    }
+  }
+}

From fcb24db4bcc01373a60d03795c7fa00847aa9774 Mon Sep 17 00:00:00 2001
From: gcarpio21 <gabriel.carpio.99@gmail.com>
Date: Sat, 14 Mar 2026 04:10:26 +0000
Subject: [PATCH 04/77] Cmdline: Added `CmdLineArguments` class.

---
 .../java_smt/cmdline/CmdLineArguments.java    | 128 ++++++++++++++++++
 1 file changed, 128 insertions(+)
 create mode 100644 src/org/sosy_lab/java_smt/cmdline/CmdLineArguments.java

diff --git a/src/org/sosy_lab/java_smt/cmdline/CmdLineArguments.java b/src/org/sosy_lab/java_smt/cmdline/CmdLineArguments.java
new file mode 100644
index 0000000000..27f0be5f63
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/cmdline/CmdLineArguments.java
@@ -0,0 +1,128 @@
+/*
+ * This file is part of JavaSMT,
+ * an API wrapper for a collection of SMT solvers:
+ * https://github.com/sosy-lab/java-smt
+ *
+ * SPDX-FileCopyrightText: 2026 Dirk Beyer <https://www.sosy-lab.org>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.sosy_lab.java_smt.cmdline;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableSortedSet;
+import java.io.PrintStream;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import org.sosy_lab.java_smt.cmdline.CmdLineArgument.CmdLineArgument1;
+import org.sosy_lab.java_smt.cmdline.CmdLineArgument.PropertyAddingCmdLineArgument;
+
+/** Processes command-line arguments for JavaSMT. */
+public final class CmdLineArguments {
+
+  private CmdLineArguments() {}
+
+  private static final ImmutableSortedSet<CmdLineArgument> CMD_LINE_ARGS =
+      ImmutableSortedSet.of(
+          new CmdLineArgument1("--solver", "-solver")
+              .settingOption("solver.solver")
+              .withDescription("Set SMT solver to use"),
+          new CmdLineArgument1("--logic", "-logic")
+              .settingOption("solver.opensmt.logic")
+              .withDescription("Set SMT logic (only for OpenSMT)"),
+          new PropertyAddingCmdLineArgument("--help", "-h", "-help")
+              .settingProperty("help", "true")
+              .withDescription("Print this help message"));
+
+  /**
+   * Processes command-line arguments and returns a map of option names to values.
+   *
+   * @param pArgs Raw command-line arguments
+   * @return Map of option names to their values
+   * @throws InvalidCmdlineArgumentException if arguments are invalid
+   */
+  public static Map<String, String> processArguments(String[] pArgs)
+      throws InvalidCmdlineArgumentException {
+    Preconditions.checkNotNull(pArgs);
+
+    Map<String, String> properties = new HashMap<>();
+    Iterator<String> argsIt = Arrays.asList(pArgs).iterator();
+
+    while (argsIt.hasNext()) {
+      String arg = argsIt.next();
+
+      boolean found = false;
+      for (CmdLineArgument cmd : CMD_LINE_ARGS) {
+        if (cmd.apply(properties, arg, argsIt)) {
+          found = true;
+          break;
+        }
+      }
+
+      if (!found) {
+        if (arg.startsWith("-")) {
+          throw new InvalidCmdlineArgumentException("Unknown command-line argument: " + arg);
+        } else {
+          if (properties.containsKey("smt2.file")) {
+            throw new InvalidCmdlineArgumentException(
+                "Multiple input files are not supported: "
+                    + properties.get("smt2.file")
+                    + " and "
+                    + arg);
+          }
+          Path file = Paths.get(arg);
+          properties.put("smt2.file", file.toString());
+        }
+      }
+    }
+
+    return properties;
+  }
+
+  static boolean isOldStyleArgument(String arg) {
+    return arg.length() > 2 && arg.startsWith("-") && !arg.startsWith("--");
+  }
+
+  private static void printVersion(PrintStream out) {
+    out.println();
+    Package pkg = CmdLineArguments.class.getPackage();
+    String version = pkg != null ? pkg.getImplementationVersion() : "unknown";
+    out.println("JavaSMT " + version);
+  }
+
+  /**
+   * Prints the help message to the given output stream.
+   *
+   * @param out The output stream to print to
+   */
+  public static void printHelp(PrintStream out) {
+    printVersion(out);
+    out.println();
+    out.println("Usage: javasmt [options] <file.smt2>");
+    out.println("Options:");
+    for (CmdLineArgument cmdLineArg : CMD_LINE_ARGS) {
+      if (!isOldStyleArgument(cmdLineArg.getMainName())) {
+        out.println(" " + cmdLineArg);
+      }
+    }
+    out.println();
+    out.println("JavaSMT executes SMT2 files using the selected solver.");
+    out.println("javasmt --solver <SOLVER> <file.smt2>");
+  }
+
+  static void putIfNotExistent(Map<String, String> properties, String key, String value)
+      throws InvalidCmdlineArgumentException {
+    if (properties.containsKey(key) && !properties.get(key).equals(value)) {
+      throw new InvalidCmdlineArgumentException(
+          String.format(
+              "Option %s specified twice on command-line with values '%s' and '%s'.",
+              key, properties.get(key), value));
+    }
+    properties.put(key, value);
+  }
+}

From b2f8b2897547fd092cfd844453aedf9a1766095a Mon Sep 17 00:00:00 2001
From: gcarpio21 <gabriel.carpio.99@gmail.com>
Date: Sat, 14 Mar 2026 04:10:59 +0000
Subject: [PATCH 05/77] Cmdline: Added `InvalidCmdlineArgumentException` class.

---
 .../InvalidCmdlineArgumentException.java      | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 src/org/sosy_lab/java_smt/cmdline/InvalidCmdlineArgumentException.java

diff --git a/src/org/sosy_lab/java_smt/cmdline/InvalidCmdlineArgumentException.java b/src/org/sosy_lab/java_smt/cmdline/InvalidCmdlineArgumentException.java
new file mode 100644
index 0000000000..eb4db2f7b3
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/cmdline/InvalidCmdlineArgumentException.java
@@ -0,0 +1,25 @@
+/*
+ * This file is part of JavaSMT,
+ * an API wrapper for a collection of SMT solvers:
+ * https://github.com/sosy-lab/java-smt
+ *
+ * SPDX-FileCopyrightText: 2026 Dirk Beyer <https://www.sosy-lab.org>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.sosy_lab.java_smt.cmdline;
+
+/** Exception thrown when an invalid command-line argument is provided. */
+public class InvalidCmdlineArgumentException extends Exception {
+
+  private static final long serialVersionUID = -6526968677815416436L;
+
+  public InvalidCmdlineArgumentException(final String msg) {
+    super(msg);
+  }
+
+  public InvalidCmdlineArgumentException(final String msg, final Throwable cause) {
+    super(msg, cause);
+  }
+}

From 6af7ff83de608e2c8bd9db56fdc9ede6a4b3c3ce Mon Sep 17 00:00:00 2001
From: gcarpio21 <gabriel.carpio.99@gmail.com>
Date: Sat, 14 Mar 2026 04:11:17 +0000
Subject: [PATCH 06/77] Cmdline: Added `Output` class.

---
 src/org/sosy_lab/java_smt/cmdline/Output.java | 60 +++++++++++++++++++
 1 file changed, 60 insertions(+)
 create mode 100644 src/org/sosy_lab/java_smt/cmdline/Output.java

diff --git a/src/org/sosy_lab/java_smt/cmdline/Output.java b/src/org/sosy_lab/java_smt/cmdline/Output.java
new file mode 100644
index 0000000000..2a4d945de7
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/cmdline/Output.java
@@ -0,0 +1,60 @@
+/*
+ * This file is part of JavaSMT,
+ * an API wrapper for a collection of SMT solvers:
+ * https://github.com/sosy-lab/java-smt
+ *
+ * SPDX-FileCopyrightText: 2026 Dirk Beyer <https://www.sosy-lab.org>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.sosy_lab.java_smt.cmdline;
+
+import com.google.errorprone.annotations.FormatMethod;
+import com.google.errorprone.annotations.FormatString;
+import java.io.PrintStream;
+import org.checkerframework.dataflow.qual.TerminatesExecution;
+import org.sosy_lab.common.annotations.SuppressForbidden;
+import org.sosy_lab.common.io.IO;
+
+/**
+ * Utility class for formatted output and error handling in JavaSMT command-line interface.
+ *
+ * <p>Provides methods for printing error messages with optional color support.
+ */
+@SuppressForbidden("System.out in this class is ok")
+final class Output {
+
+  private Output() {}
+
+  private static final PrintStream ERROR_OUTPUT = System.err;
+
+  private static final boolean USE_COLORS = IO.mayUseColorForOutput();
+  private static final String ERROR_COLOR = "\033[31;1m"; // bold red
+  private static final String REGULAR_COLOR = "\033[m";
+
+  @TerminatesExecution
+  @FormatMethod
+  static RuntimeException fatalError(String msg, Object... args) {
+    coloredOutput(ERROR_COLOR, msg, args);
+    System.exit(JavaSMTMain.ERROR_EXIT_CODE);
+    return new RuntimeException("never reached");
+  }
+
+  @FormatMethod
+  private static void coloredOutput(String color, @FormatString String msg, Object... args) {
+    ERROR_OUTPUT.println();
+
+    if (USE_COLORS) {
+      ERROR_OUTPUT.print(color);
+    }
+
+    ERROR_OUTPUT.printf(msg, args);
+
+    if (USE_COLORS) {
+      ERROR_OUTPUT.print(REGULAR_COLOR);
+    }
+
+    ERROR_OUTPUT.println();
+  }
+}

From df6dd0c745e1479fb528b09588d01cb8062ed1da Mon Sep 17 00:00:00 2001
From: gcarpio21 <gabriel.carpio.99@gmail.com>
Date: Sat, 14 Mar 2026 04:11:44 +0000
Subject: [PATCH 07/77] Cmdline: Added `JavaSMTMainTest` test class.

---
 .../java_smt/test/JavaSMTMainTest.java        | 114 ++++++++++++++++++
 1 file changed, 114 insertions(+)
 create mode 100644 src/org/sosy_lab/java_smt/test/JavaSMTMainTest.java

diff --git a/src/org/sosy_lab/java_smt/test/JavaSMTMainTest.java b/src/org/sosy_lab/java_smt/test/JavaSMTMainTest.java
new file mode 100644
index 0000000000..cd0e096919
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/JavaSMTMainTest.java
@@ -0,0 +1,114 @@
+/*
+ * This file is part of JavaSMT,
+ * an API wrapper for a collection of SMT solvers:
+ * https://github.com/sosy-lab/java-smt
+ *
+ * SPDX-FileCopyrightText: 2026 Dirk Beyer <https://www.sosy-lab.org>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.sosy_lab.java_smt.test;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import java.util.Map;
+import org.junit.Test;
+import org.sosy_lab.java_smt.cmdline.CmdLineArguments;
+import org.sosy_lab.java_smt.cmdline.InvalidCmdlineArgumentException;
+
+public class JavaSMTMainTest {
+
+  @Test
+  public void testProcessArgumentsWithSolverAndFile() throws Exception {
+    Map<String, String> result =
+        CmdLineArguments.processArguments(new String[] {"--solver", "Z3", "test.smt2"});
+    assertThat(result.get("solver.solver")).isEqualTo("Z3");
+    assertThat(result.get("smt2.file")).isEqualTo("test.smt2");
+  }
+
+  @Test
+  public void testProcessArgumentsSolverShortFlag() throws Exception {
+    Map<String, String> result =
+        CmdLineArguments.processArguments(new String[] {"-solver", "SMTINTERPOL", "file.smt2"});
+    assertThat(result.get("solver.solver")).isEqualTo("SMTINTERPOL");
+  }
+
+  @Test
+  public void testProcessArgumentsHelp() throws Exception {
+    Map<String, String> result = CmdLineArguments.processArguments(new String[] {"--help"});
+    assertThat(result).containsKey("help");
+  }
+
+  @Test
+  public void testProcessArgumentsHelpShortFlag() throws Exception {
+    Map<String, String> result = CmdLineArguments.processArguments(new String[] {"-h"});
+    assertThat(result).containsKey("help");
+  }
+
+  @Test
+  public void testProcessArgumentsOnlyFile() throws Exception {
+    Map<String, String> result = CmdLineArguments.processArguments(new String[] {"input.smt2"});
+    assertThat(result.get("smt2.file")).isEqualTo("input.smt2");
+  }
+
+  @Test(expected = InvalidCmdlineArgumentException.class)
+  public void testProcessArgumentsMultipleFiles() throws Exception {
+    CmdLineArguments.processArguments(new String[] {"file1.smt2", "file2.smt2"});
+  }
+
+  @Test(expected = InvalidCmdlineArgumentException.class)
+  public void testProcessArgumentsUnknownArgument() throws Exception {
+    CmdLineArguments.processArguments(new String[] {"--unknown", "file.smt2"});
+  }
+
+  @Test(expected = InvalidCmdlineArgumentException.class)
+  public void testProcessArgumentsSolverMissingValue() throws Exception {
+    CmdLineArguments.processArguments(new String[] {"--solver"});
+  }
+
+  @Test
+  public void testProcessArgumentsFileBeforeSolver() throws Exception {
+    Map<String, String> result =
+        CmdLineArguments.processArguments(new String[] {"test.smt2", "--solver", "Z3"});
+    assertThat(result.get("smt2.file")).isEqualTo("test.smt2");
+    assertThat(result.get("solver.solver")).isEqualTo("Z3");
+  }
+
+  @Test
+  public void testProcessArgumentsDefaultSolver() throws Exception {
+    Map<String, String> result = CmdLineArguments.processArguments(new String[] {"test.smt2"});
+    assertThat(result.get("smt2.file")).isEqualTo("test.smt2");
+    assertThat(result.get("solver.solver")).isNull();
+  }
+
+  @Test
+  public void testProcessArgumentsWithLogic() throws Exception {
+    Map<String, String> result =
+        CmdLineArguments.processArguments(new String[] {"--logic", "QF_LIA", "test.smt2"});
+    assertThat(result.get("solver.opensmt.logic")).isEqualTo("QF_LIA");
+    assertThat(result.get("smt2.file")).isEqualTo("test.smt2");
+  }
+
+  @Test
+  public void testProcessArgumentsWithLogicShortFlag() throws Exception {
+    Map<String, String> result =
+        CmdLineArguments.processArguments(new String[] {"-logic", "QF_UF", "test.smt2"});
+    assertThat(result.get("solver.opensmt.logic")).isEqualTo("QF_UF");
+  }
+
+  @Test
+  public void testProcessArgumentsWithSolverAndLogic() throws Exception {
+    Map<String, String> result =
+        CmdLineArguments.processArguments(
+            new String[] {"--solver", "OPENSMT", "--logic", "QF_LIA", "test.smt2"});
+    assertThat(result.get("solver.solver")).isEqualTo("OPENSMT");
+    assertThat(result.get("solver.opensmt.logic")).isEqualTo("QF_LIA");
+    assertThat(result.get("smt2.file")).isEqualTo("test.smt2");
+  }
+
+  @Test(expected = InvalidCmdlineArgumentException.class)
+  public void testProcessArgumentsLogicMissingValue() throws Exception {
+    CmdLineArguments.processArguments(new String[] {"--logic"});
+  }
+}

From 685ecfd4e74b29863440794fdec754e285399c60 Mon Sep 17 00:00:00 2001
From: gcarpio21 <gabriel.carpio.99@gmail.com>
Date: Sat, 14 Mar 2026 04:12:13 +0000
Subject: [PATCH 08/77] Cmdline: Added package info to `cmdline`.

---
 .../sosy_lab/java_smt/cmdline/package-info.java    | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 src/org/sosy_lab/java_smt/cmdline/package-info.java

diff --git a/src/org/sosy_lab/java_smt/cmdline/package-info.java b/src/org/sosy_lab/java_smt/cmdline/package-info.java
new file mode 100644
index 0000000000..ceaea29cff
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/cmdline/package-info.java
@@ -0,0 +1,14 @@
+/*
+ * This file is part of JavaSMT,
+ * an API wrapper for a collection of SMT solvers:
+ * https://github.com/sosy-lab/java-smt
+ *
+ * SPDX-FileCopyrightText: 2026 Dirk Beyer <https://www.sosy-lab.org>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The frontend of JavaSMT for using it as a standalone application on the command line.
+ */
+package org.sosy_lab.java_smt.cmdline;
\ No newline at end of file

From 9f678f09b5d7e5128e611a52d7d97065fc968be5 Mon Sep 17 00:00:00 2001
From: gcarpio21 <gabriel.carpio.99@gmail.com>
Date: Thu, 19 Mar 2026 02:10:06 +0000
Subject: [PATCH 09/77] refaster.

---
 src/org/sosy_lab/java_smt/cmdline/CmdLineArguments.java | 3 +--
 src/org/sosy_lab/java_smt/cmdline/JavaSMTMain.java      | 6 +++---
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/cmdline/CmdLineArguments.java b/src/org/sosy_lab/java_smt/cmdline/CmdLineArguments.java
index 27f0be5f63..f2de975f3c 100644
--- a/src/org/sosy_lab/java_smt/cmdline/CmdLineArguments.java
+++ b/src/org/sosy_lab/java_smt/cmdline/CmdLineArguments.java
@@ -14,7 +14,6 @@
 import com.google.common.collect.ImmutableSortedSet;
 import java.io.PrintStream;
 import java.nio.file.Path;
-import java.nio.file.Paths;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Iterator;
@@ -75,7 +74,7 @@ public static Map<String, String> processArguments(String[] pArgs)
                     + " and "
                     + arg);
           }
-          Path file = Paths.get(arg);
+          Path file = Path.of(arg);
           properties.put("smt2.file", file.toString());
         }
       }
diff --git a/src/org/sosy_lab/java_smt/cmdline/JavaSMTMain.java b/src/org/sosy_lab/java_smt/cmdline/JavaSMTMain.java
index c5c58facd0..07c572b84a 100644
--- a/src/org/sosy_lab/java_smt/cmdline/JavaSMTMain.java
+++ b/src/org/sosy_lab/java_smt/cmdline/JavaSMTMain.java
@@ -14,7 +14,7 @@
 import com.google.common.collect.ImmutableMap;
 import java.io.IOException;
 import java.nio.file.Files;
-import java.nio.file.Paths;
+import java.nio.file.Path;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
@@ -91,7 +91,7 @@ public static void main(String[] args) {
       return;
     }
 
-    if (!Files.isReadable(Paths.get(options.smt2File))) {
+    if (!Files.isReadable(Path.of(options.smt2File))) {
       throw Output.fatalError(
           "Please provide a valid, readable SMT2 file: %s", options.smt2File);
     }
@@ -141,7 +141,7 @@ private static void run(Configuration config, LogManager logManager, MainOptions
 
     String input;
     try {
-      input = Files.readString(Paths.get(options.smt2File));
+      input = Files.readString(Path.of(options.smt2File));
     } catch (IOException e) {
       throw Output.fatalError("Could not read SMT2 file: %s", e.getMessage());
     }

From b4a89b673200e3838e831d8bd83ca8d562b507b9 Mon Sep 17 00:00:00 2001
From: gcarpio21 <gabriel.carpio.99@gmail.com>
Date: Thu, 19 Mar 2026 02:19:17 +0000
Subject: [PATCH 10/77] checkstyle.

---
 src/org/sosy_lab/java_smt/cmdline/JavaSMTMain.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/org/sosy_lab/java_smt/cmdline/JavaSMTMain.java b/src/org/sosy_lab/java_smt/cmdline/JavaSMTMain.java
index 07c572b84a..7da1403e74 100644
--- a/src/org/sosy_lab/java_smt/cmdline/JavaSMTMain.java
+++ b/src/org/sosy_lab/java_smt/cmdline/JavaSMTMain.java
@@ -43,7 +43,7 @@
  * and reports the result (sat/unsat/unknown).
  */
 @SuppressForbidden("System.out in this class is ok")
-public class JavaSMTMain {
+public final class JavaSMTMain {
 
   static final int ERROR_EXIT_CODE = 1;
 

From aba6237471da5728fa474ec6aece9d64beda9509 Mon Sep 17 00:00:00 2001
From: gcarpio21 <gabriel.carpio.99@gmail.com>
Date: Thu, 19 Mar 2026 02:21:42 +0000
Subject: [PATCH 11/77] Cmdline: removed unused argument in a helper function
 from `CmdLineArgument`.

---
 src/org/sosy_lab/java_smt/cmdline/CmdLineArgument.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/cmdline/CmdLineArgument.java b/src/org/sosy_lab/java_smt/cmdline/CmdLineArgument.java
index c600ad21cd..a1858145a0 100644
--- a/src/org/sosy_lab/java_smt/cmdline/CmdLineArgument.java
+++ b/src/org/sosy_lab/java_smt/cmdline/CmdLineArgument.java
@@ -100,13 +100,13 @@ CmdLineArgument1 settingOption(String pOption) {
     final void apply0(Map<String, String> properties, String currentArg, Iterator<String> args)
         throws InvalidCmdlineArgumentException {
       if (args.hasNext()) {
-        handleArg(properties, currentArg, args.next());
+        handleArg(properties, args.next());
       } else {
         throw new InvalidCmdlineArgumentException(currentArg + " argument missing.");
       }
     }
 
-    void handleArg(Map<String, String> pProperties, String pCurrentArg, String pArgValue)
+    void handleArg(Map<String, String> pProperties, String pArgValue)
         throws InvalidCmdlineArgumentException {
       checkState(option != null);
       putIfNotExistent(pProperties, option, pArgValue);

From e90044b57dc7ed8b4704dc70da63e06cb6f2bc5b Mon Sep 17 00:00:00 2001
From: gcarpio21 <gabriel.carpio.99@gmail.com>
Date: Thu, 19 Mar 2026 02:26:51 +0000
Subject: [PATCH 12/77] format.

---
 src/org/sosy_lab/java_smt/cmdline/JavaSMTMain.java  | 3 +--
 src/org/sosy_lab/java_smt/cmdline/package-info.java | 6 ++----
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/cmdline/JavaSMTMain.java b/src/org/sosy_lab/java_smt/cmdline/JavaSMTMain.java
index 7da1403e74..d2496bcccd 100644
--- a/src/org/sosy_lab/java_smt/cmdline/JavaSMTMain.java
+++ b/src/org/sosy_lab/java_smt/cmdline/JavaSMTMain.java
@@ -92,8 +92,7 @@ public static void main(String[] args) {
     }
 
     if (!Files.isReadable(Path.of(options.smt2File))) {
-      throw Output.fatalError(
-          "Please provide a valid, readable SMT2 file: %s", options.smt2File);
+      throw Output.fatalError("Please provide a valid, readable SMT2 file: %s", options.smt2File);
     }
 
     run(config, logManager, options);
diff --git a/src/org/sosy_lab/java_smt/cmdline/package-info.java b/src/org/sosy_lab/java_smt/cmdline/package-info.java
index ceaea29cff..6a970cc13f 100644
--- a/src/org/sosy_lab/java_smt/cmdline/package-info.java
+++ b/src/org/sosy_lab/java_smt/cmdline/package-info.java
@@ -8,7 +8,5 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-/**
- * The frontend of JavaSMT for using it as a standalone application on the command line.
- */
-package org.sosy_lab.java_smt.cmdline;
\ No newline at end of file
+/** The frontend of JavaSMT for using it as a standalone application on the command line. */
+package org.sosy_lab.java_smt.cmdline;

From 7e5485a796c630cca8bc6ca7d13db5ebf28c5512 Mon Sep 17 00:00:00 2001
From: gcarpio21 <gabriel.carpio.99@gmail.com>
Date: Tue, 31 Mar 2026 19:22:21 +0000
Subject: [PATCH 13/77] Cmdline: removed preconditions check that the
 (set-logic) command should be at the start of the smt2 file to be parsed set
 by private helper method `sanitize` in `AbstractFormulaManager`.

---
 .../sosy_lab/java_smt/basicimpl/AbstractFormulaManager.java   | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/org/sosy_lab/java_smt/basicimpl/AbstractFormulaManager.java b/src/org/sosy_lab/java_smt/basicimpl/AbstractFormulaManager.java
index 1bb109f98f..f95c261801 100644
--- a/src/org/sosy_lab/java_smt/basicimpl/AbstractFormulaManager.java
+++ b/src/org/sosy_lab/java_smt/basicimpl/AbstractFormulaManager.java
@@ -401,7 +401,9 @@ private String sanitize(String formulaStr) {
     for (String token : tokens) {
       if (Tokenizer.isSetLogicToken(token)) {
         // Skip the (set-logic ...) command at the beginning of the input
-        Preconditions.checkArgument(pos == 0);
+        // The command at the top is not (set-logic) but (set-info) for some non-incremental
+        // benchmarks from the SMT-LIB release 2025
+        // Preconditions.checkArgument(pos == 0);
 
       } else if (Tokenizer.isExitToken(token)) {
         // Skip the (exit) command at the end of the input

From 2fbab213d22b1fa4fb44ad9c50c0c357c5a52f06 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Sat, 25 Apr 2026 14:50:22 +0200
Subject: [PATCH 14/77] boolean formular manager: horn api

This makes it easy to create horn clauses in the form: `(constraint \/ body) => head`.
---
 .../java_smt/api/BooleanFormulaManager.java   | 43 +++++++++++++++++++
 .../AbstractBooleanFormulaManager.java        |  7 +++
 .../DebuggingBooleanFormulaManager.java       |  7 +++
 .../StatisticsBooleanFormulaManager.java      |  8 ++++
 .../SynchronizedBooleanFormulaManager.java    | 31 +++++++++++++
 .../trace/TraceBooleanFormulaManager.java     | 13 ++++++
 .../test/BooleanFormulaManagerTest.java       | 29 +++++++++++++
 7 files changed, 138 insertions(+)

diff --git a/src/org/sosy_lab/java_smt/api/BooleanFormulaManager.java b/src/org/sosy_lab/java_smt/api/BooleanFormulaManager.java
index 3777fee198..677024fb1c 100644
--- a/src/org/sosy_lab/java_smt/api/BooleanFormulaManager.java
+++ b/src/org/sosy_lab/java_smt/api/BooleanFormulaManager.java
@@ -203,4 +203,47 @@ BooleanFormula transformRecursively(
    * @param flatten If {@code true}, flatten recursively.
    */
   Set<BooleanFormula> toDisjunctionArgs(BooleanFormula f, boolean flatten);
+
+  /**
+   * Creates a constrained horn clause
+   * {@code (constraint \/ body) => head}
+   * @param head Head of horn clause
+   * @param body Body of horn clause
+   * @param constraint Constraint of horn clause
+   * @return boolean formula representation of horn clause
+   */
+  BooleanFormula makeHornClause(BooleanFormula head,
+                            Collection<BooleanFormula> body, BooleanFormula constraint);
+
+  /**
+   * Creates a constrained horn clause
+   * {@code body => head}
+   * @param head Head of horn clause
+   * @param body Body of horn clause
+   * @return boolean formula representation of horn clause
+   */
+  default BooleanFormula makeHornClause(BooleanFormula head,
+                            Collection<BooleanFormula> body) {
+    return makeHornClause(head, body, makeTrue());
+  }
+
+  /**
+   * Creates a horn clause
+   * {@code body => true}
+   * @param body Body of horn clause
+   * @return boolean formula representation of horn clause
+   */
+  default BooleanFormula makeHornClause(Collection<BooleanFormula> body) {
+    return makeHornClause(makeTrue(), body);
+  }
+  /**
+   * Creates a constrained horn clause
+   * {@code (constraint \/ body) => true}
+   * @param body Body of horn clause
+   * @param constraint Constraint of horn clause
+   * @return boolean formula representation of horn clause
+   */
+  default BooleanFormula makeHornClause(Collection<BooleanFormula> body, BooleanFormula constraint) {
+    return makeHornClause(makeTrue(), body, constraint);
+  }
 }
diff --git a/src/org/sosy_lab/java_smt/basicimpl/AbstractBooleanFormulaManager.java b/src/org/sosy_lab/java_smt/basicimpl/AbstractBooleanFormulaManager.java
index 8cbfa7f41d..3cdf1d364e 100644
--- a/src/org/sosy_lab/java_smt/basicimpl/AbstractBooleanFormulaManager.java
+++ b/src/org/sosy_lab/java_smt/basicimpl/AbstractBooleanFormulaManager.java
@@ -480,4 +480,11 @@ public Set<BooleanFormula> visitFunction(
           return visitDefault(f);
         }
       };
+
+  @Override
+  public BooleanFormula makeHornClause(BooleanFormula head, Collection<BooleanFormula> body,
+                                       BooleanFormula constraint) {
+
+    return implication(and(constraint, and(body)), head);
+  }
 }
diff --git a/src/org/sosy_lab/java_smt/delegate/debugging/DebuggingBooleanFormulaManager.java b/src/org/sosy_lab/java_smt/delegate/debugging/DebuggingBooleanFormulaManager.java
index 9c14e185d4..077f698f91 100644
--- a/src/org/sosy_lab/java_smt/delegate/debugging/DebuggingBooleanFormulaManager.java
+++ b/src/org/sosy_lab/java_smt/delegate/debugging/DebuggingBooleanFormulaManager.java
@@ -234,4 +234,11 @@ public Set<BooleanFormula> toDisjunctionArgs(BooleanFormula f, boolean flatten)
     }
     return result;
   }
+  @Override
+  public BooleanFormula makeHornClause(
+      BooleanFormula head,
+      Collection<BooleanFormula> body,
+      BooleanFormula constraint) { // TODO
+    return delegate.makeHornClause(head, body, constraint);
+  }
 }
diff --git a/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsBooleanFormulaManager.java b/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsBooleanFormulaManager.java
index 2a9b21840e..2fb6210e69 100644
--- a/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsBooleanFormulaManager.java
+++ b/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsBooleanFormulaManager.java
@@ -154,4 +154,12 @@ public Set<BooleanFormula> toConjunctionArgs(BooleanFormula pF, boolean pFlatten
   public Set<BooleanFormula> toDisjunctionArgs(BooleanFormula pF, boolean pFlatten) {
     return delegate.toDisjunctionArgs(pF, pFlatten);
   }
+
+  @Override
+  public BooleanFormula makeHornClause(
+      BooleanFormula head,
+      Collection<BooleanFormula> body,
+      BooleanFormula constraint) {
+      return delegate.makeHornClause(head, body, constraint);
+  }
 }
diff --git a/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedBooleanFormulaManager.java b/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedBooleanFormulaManager.java
index 48d2551ce7..418a1b3f60 100644
--- a/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedBooleanFormulaManager.java
+++ b/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedBooleanFormulaManager.java
@@ -183,4 +183,35 @@ public Set<BooleanFormula> toDisjunctionArgs(BooleanFormula pF, boolean pFlatten
       return delegate.toDisjunctionArgs(pF, pFlatten);
     }
   }
+
+  @Override
+  public BooleanFormula makeHornClause(
+      BooleanFormula head,
+      Collection<BooleanFormula> body,
+      BooleanFormula constraint) {
+    synchronized (sync){
+      return delegate.makeHornClause(head, body, constraint);
+    }
+  }
+
+  @Override
+  public BooleanFormula makeHornClause(BooleanFormula head, Collection<BooleanFormula> body) {
+    synchronized (sync){
+      return delegate.makeHornClause(head, body);
+    }
+  }
+
+  @Override
+  public BooleanFormula makeHornClause(Collection<BooleanFormula> body) {
+    synchronized (sync){
+      return delegate.makeHornClause(body);
+    }
+  }
+
+  @Override
+  public BooleanFormula makeHornClause(Collection<BooleanFormula> body, BooleanFormula constraint) {
+    synchronized (sync){
+      return delegate.makeHornClause(body, constraint);
+    }
+  }
 }
diff --git a/src/org/sosy_lab/java_smt/delegate/trace/TraceBooleanFormulaManager.java b/src/org/sosy_lab/java_smt/delegate/trace/TraceBooleanFormulaManager.java
index 8a422012b2..0f0c8a95c9 100644
--- a/src/org/sosy_lab/java_smt/delegate/trace/TraceBooleanFormulaManager.java
+++ b/src/org/sosy_lab/java_smt/delegate/trace/TraceBooleanFormulaManager.java
@@ -200,4 +200,17 @@ public Set<BooleanFormula> toDisjunctionArgs(BooleanFormula f, boolean flatten)
             "toDisjunctionArgs(%s, %s)".formatted(logger.toVariable(f), flatten),
             () -> delegate.toDisjunctionArgs(f, flatten)));
   }
+
+  @Override
+  public BooleanFormula makeHornClause(
+      BooleanFormula head,
+      Collection<BooleanFormula> body,
+      BooleanFormula constraint) {
+    return mgr.rebuild(
+        logger.logDefDiscard(
+            "mgr.getBooleanFormulaManager()",
+            "makeHornClause(%s, %s, %s)".formatted(logger.toVariable(head),
+                logger.toVariable(body), logger.toVariable(constraint)),
+            () -> delegate.makeHornClause(head, body, constraint)));
+  }
 }
diff --git a/src/org/sosy_lab/java_smt/test/BooleanFormulaManagerTest.java b/src/org/sosy_lab/java_smt/test/BooleanFormulaManagerTest.java
index 594cbeddac..180569d042 100644
--- a/src/org/sosy_lab/java_smt/test/BooleanFormulaManagerTest.java
+++ b/src/org/sosy_lab/java_smt/test/BooleanFormulaManagerTest.java
@@ -18,6 +18,7 @@
 import org.junit.Test;
 import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
 import org.sosy_lab.java_smt.api.BooleanFormula;
+import org.sosy_lab.java_smt.api.NumeralFormula.IntegerFormula;
 import org.sosy_lab.java_smt.api.SolverException;
 
 /**
@@ -412,4 +413,32 @@ public void simplifiedIfThenElse() {
     assertThat(bmgr.ifThenElse(var1, fTrue, fFalse)).isEqualTo(var1);
     assertThat(bmgr.ifThenElse(var1, fFalse, fTrue)).isEqualTo(bmgr.not(var1));
   }
+
+  @Test
+  public void hornBuilding() throws SolverException, InterruptedException {
+    BooleanFormula var1 = bmgr.makeVariable("var1");
+    BooleanFormula var2 = bmgr.makeVariable("var2");
+    BooleanFormula var3 = bmgr.makeVariable("var3");
+
+    assertThatFormula(bmgr.makeHornClause(var1, ImmutableList.of(var2, var3))).isEquisatisfiableTo(
+        bmgr.or(bmgr.not(bmgr.and(var2,var3)), var1));
+  }
+
+  @Test
+  public void hornBuildingConstraint() throws SolverException, InterruptedException {
+    assume()
+        .that(imgr)
+        .isNotNull();
+
+    BooleanFormula var1 = bmgr.makeVariable("var1");
+    BooleanFormula var2 = bmgr.makeVariable("var2");
+    BooleanFormula var3 = bmgr.makeVariable("var3");
+
+    IntegerFormula var4 = imgr.makeVariable("var4");
+    IntegerFormula n1 = imgr.makeNumber(1);
+    BooleanFormula c1 = imgr.greaterThan(var4, n1);
+
+    assertThatFormula(bmgr.makeHornClause(var1, ImmutableList.of(var2, var3), c1)).isEquisatisfiableTo(bmgr.or(c1,
+        bmgr.not(bmgr.and(var2, var3)), var1));
+  }
 }

From 2bee1acac2ce107a172c06893c0f20d0bd4b23b3 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Sat, 25 Apr 2026 14:50:22 +0200
Subject: [PATCH 15/77] boolean formular manager: horn api

This makes it easy to create horn clauses in the form: `(constraint \/ body) => head`.
---
 .../java_smt/api/BooleanFormulaManager.java   | 65 +++++++++++++------
 .../SynchronizedBooleanFormulaManager.java    |  8 +--
 .../test/BooleanFormulaManagerTest.java       | 29 +++++----
 3 files changed, 65 insertions(+), 37 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/api/BooleanFormulaManager.java b/src/org/sosy_lab/java_smt/api/BooleanFormulaManager.java
index 677024fb1c..32df5500a6 100644
--- a/src/org/sosy_lab/java_smt/api/BooleanFormulaManager.java
+++ b/src/org/sosy_lab/java_smt/api/BooleanFormulaManager.java
@@ -17,7 +17,9 @@
 import org.sosy_lab.java_smt.api.visitors.BooleanFormulaVisitor;
 import org.sosy_lab.java_smt.api.visitors.TraversalProcess;
 
-/** Manager for dealing with boolean formulas. */
+/**
+ * Manager for dealing with boolean formulas.
+ */
 public interface BooleanFormulaManager {
 
   /**
@@ -30,10 +32,14 @@ default BooleanFormula makeBoolean(boolean value) {
     return value ? makeTrue() : makeFalse();
   }
 
-  /** Shortcut for {@code makeBoolean(true)}. */
+  /**
+   * Shortcut for {@code makeBoolean(true)}.
+   */
   BooleanFormula makeTrue();
 
-  /** Shortcut for {@code makeBoolean(false)}. */
+  /**
+   * Shortcut for {@code makeBoolean(false)}.
+   */
   BooleanFormula makeFalse();
 
   /**
@@ -81,8 +87,8 @@ default BooleanFormula makeBoolean(boolean value) {
    * Creates a formula representing {@code IF cond THEN f1 ELSE f2}.
    *
    * @param cond a Formula
-   * @param f1 a Formula
-   * @param f2 a Formula
+   * @param f1   a Formula
+   * @param f2   a Formula
    * @return (IF cond THEN f1 ELSE f2)
    */
   <T extends Formula> T ifThenElse(BooleanFormula cond, T f1, T f2);
@@ -116,7 +122,9 @@ default BooleanFormula and(BooleanFormula... bits) {
     return and(ImmutableList.copyOf(bits));
   }
 
-  /** Return a stream {@link Collector} that creates a conjunction of all elements in the stream. */
+  /**
+   * Return a stream {@link Collector} that creates a conjunction of all elements in the stream.
+   */
   Collector<BooleanFormula, ?, BooleanFormula> toConjunction();
 
   /**
@@ -140,13 +148,19 @@ default BooleanFormula or(BooleanFormula... bits) {
     return or(ImmutableList.copyOf(bits));
   }
 
-  /** Return a stream {@link Collector} that creates a disjunction of all elements in the stream. */
+  /**
+   * Return a stream {@link Collector} that creates a disjunction of all elements in the stream.
+   */
   Collector<BooleanFormula, ?, BooleanFormula> toDisjunction();
 
-  /** Creates a formula representing XOR of the two arguments. */
+  /**
+   * Creates a formula representing XOR of the two arguments.
+   */
   BooleanFormula xor(BooleanFormula bits1, BooleanFormula bits2);
 
-  /** Visit the formula with the given visitor. */
+  /**
+   * Visit the formula with the given visitor.
+   */
   @CanIgnoreReturnValue
   <R> R visit(BooleanFormula pFormula, BooleanFormulaVisitor<R> visitor);
 
@@ -205,45 +219,54 @@ BooleanFormula transformRecursively(
   Set<BooleanFormula> toDisjunctionArgs(BooleanFormula f, boolean flatten);
 
   /**
-   * Creates a constrained horn clause
+   * Creates a constrained horn clause.
    * {@code (constraint \/ body) => head}
-   * @param head Head of horn clause
-   * @param body Body of horn clause
+   *
+   * @param head       Head of horn clause
+   * @param body       Body of horn clause
    * @param constraint Constraint of horn clause
    * @return boolean formula representation of horn clause
    */
-  BooleanFormula makeHornClause(BooleanFormula head,
-                            Collection<BooleanFormula> body, BooleanFormula constraint);
+  BooleanFormula makeHornClause(
+      BooleanFormula head,
+      Collection<BooleanFormula> body, BooleanFormula constraint);
 
   /**
-   * Creates a constrained horn clause
+   * Creates a constrained horn clause.
    * {@code body => head}
+   *
    * @param head Head of horn clause
    * @param body Body of horn clause
    * @return boolean formula representation of horn clause
    */
-  default BooleanFormula makeHornClause(BooleanFormula head,
-                            Collection<BooleanFormula> body) {
+  default BooleanFormula makeHornClause(
+      BooleanFormula head,
+      Collection<BooleanFormula> body) {
     return makeHornClause(head, body, makeTrue());
   }
 
   /**
-   * Creates a horn clause
+   * Creates a horn clause.
    * {@code body => true}
+   *
    * @param body Body of horn clause
    * @return boolean formula representation of horn clause
    */
   default BooleanFormula makeHornClause(Collection<BooleanFormula> body) {
     return makeHornClause(makeTrue(), body);
   }
+
   /**
-   * Creates a constrained horn clause
+   * Creates a constrained horn clause.
    * {@code (constraint \/ body) => true}
-   * @param body Body of horn clause
+   *
+   * @param body       Body of horn clause
    * @param constraint Constraint of horn clause
    * @return boolean formula representation of horn clause
    */
-  default BooleanFormula makeHornClause(Collection<BooleanFormula> body, BooleanFormula constraint) {
+  default BooleanFormula makeHornClause(
+      Collection<BooleanFormula> body,
+      BooleanFormula constraint) {
     return makeHornClause(makeTrue(), body, constraint);
   }
 }
diff --git a/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedBooleanFormulaManager.java b/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedBooleanFormulaManager.java
index 418a1b3f60..9c1f0ab72e 100644
--- a/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedBooleanFormulaManager.java
+++ b/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedBooleanFormulaManager.java
@@ -189,28 +189,28 @@ public BooleanFormula makeHornClause(
       BooleanFormula head,
       Collection<BooleanFormula> body,
       BooleanFormula constraint) {
-    synchronized (sync){
+    synchronized (sync) {
       return delegate.makeHornClause(head, body, constraint);
     }
   }
 
   @Override
   public BooleanFormula makeHornClause(BooleanFormula head, Collection<BooleanFormula> body) {
-    synchronized (sync){
+    synchronized (sync) {
       return delegate.makeHornClause(head, body);
     }
   }
 
   @Override
   public BooleanFormula makeHornClause(Collection<BooleanFormula> body) {
-    synchronized (sync){
+    synchronized (sync) {
       return delegate.makeHornClause(body);
     }
   }
 
   @Override
   public BooleanFormula makeHornClause(Collection<BooleanFormula> body, BooleanFormula constraint) {
-    synchronized (sync){
+    synchronized (sync) {
       return delegate.makeHornClause(body, constraint);
     }
   }
diff --git a/src/org/sosy_lab/java_smt/test/BooleanFormulaManagerTest.java b/src/org/sosy_lab/java_smt/test/BooleanFormulaManagerTest.java
index 180569d042..23f4f973e6 100644
--- a/src/org/sosy_lab/java_smt/test/BooleanFormulaManagerTest.java
+++ b/src/org/sosy_lab/java_smt/test/BooleanFormulaManagerTest.java
@@ -416,12 +416,14 @@ public void simplifiedIfThenElse() {
 
   @Test
   public void hornBuilding() throws SolverException, InterruptedException {
-    BooleanFormula var1 = bmgr.makeVariable("var1");
-    BooleanFormula var2 = bmgr.makeVariable("var2");
-    BooleanFormula var3 = bmgr.makeVariable("var3");
+    BooleanFormula a = bmgr.makeVariable("a");
+    BooleanFormula b = bmgr.makeVariable("b");
+    BooleanFormula c = bmgr.makeVariable("c");
 
-    assertThatFormula(bmgr.makeHornClause(var1, ImmutableList.of(var2, var3))).isEquisatisfiableTo(
-        bmgr.or(bmgr.not(bmgr.and(var2,var3)), var1));
+    var horn = bmgr.makeHornClause(a, ImmutableList.of(b, c));
+    var expected = bmgr.or(a, bmgr.not(b), bmgr.not(c));
+
+    assertThatFormula(horn).isEquivalentTo(expected);
   }
 
   @Test
@@ -430,15 +432,18 @@ public void hornBuildingConstraint() throws SolverException, InterruptedExceptio
         .that(imgr)
         .isNotNull();
 
-    BooleanFormula var1 = bmgr.makeVariable("var1");
-    BooleanFormula var2 = bmgr.makeVariable("var2");
-    BooleanFormula var3 = bmgr.makeVariable("var3");
+    BooleanFormula a = bmgr.makeVariable("a");
+    BooleanFormula b = bmgr.makeVariable("b");
+    BooleanFormula c = bmgr.makeVariable("c");
 
-    IntegerFormula var4 = imgr.makeVariable("var4");
+    IntegerFormula d = imgr.makeVariable("d");
     IntegerFormula n1 = imgr.makeNumber(1);
-    BooleanFormula c1 = imgr.greaterThan(var4, n1);
+    BooleanFormula c1 = imgr.greaterThan(d, n1);
+
+
+    var horn = bmgr.makeHornClause(a, ImmutableList.of(b, c), c1);
+    var expected = bmgr.or( a,bmgr.not(c1), bmgr.not(b), bmgr.not(c));
 
-    assertThatFormula(bmgr.makeHornClause(var1, ImmutableList.of(var2, var3), c1)).isEquisatisfiableTo(bmgr.or(c1,
-        bmgr.not(bmgr.and(var2, var3)), var1));
+    assertThatFormula(horn).isEquivalentTo(expected);
   }
 }

From 1bfacdefc9b83d31b0910bbbf712931d051bbb45 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Tue, 28 Apr 2026 12:50:45 +0200
Subject: [PATCH 16/77] boolean formular manager: horn api

This makes it easy to create horn clauses in the form: `(constraint \/ body) => head`.
---
 src/org/sosy_lab/java_smt/test/BooleanFormulaManagerTest.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/org/sosy_lab/java_smt/test/BooleanFormulaManagerTest.java b/src/org/sosy_lab/java_smt/test/BooleanFormulaManagerTest.java
index 23f4f973e6..0119d32e17 100644
--- a/src/org/sosy_lab/java_smt/test/BooleanFormulaManagerTest.java
+++ b/src/org/sosy_lab/java_smt/test/BooleanFormulaManagerTest.java
@@ -442,7 +442,7 @@ public void hornBuildingConstraint() throws SolverException, InterruptedExceptio
 
 
     var horn = bmgr.makeHornClause(a, ImmutableList.of(b, c), c1);
-    var expected = bmgr.or( a,bmgr.not(c1), bmgr.not(b), bmgr.not(c));
+    var expected = bmgr.or(a, bmgr.not(c1), bmgr.not(b), bmgr.not(c));
 
     assertThatFormula(horn).isEquivalentTo(expected);
   }

From 62dda73df98fceeae9ac03b121864b26b64a17c9 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Wed, 4 Mar 2026 15:22:11 +0100
Subject: [PATCH 17/77] add eldarica to classpath

This is most certainly not the intended way, the `ivy.xml` adds multiple repository. But good enough for now until eldarica is published to https://www.sosy-lab.org/ivy/uuverifiers/
---
 .classpath            |  1 +
 .idea/JavaSMT.iml     |  1 +
 build.xml             |  3 ++-
 build/ivysettings.xml | 17 +++++++++++------
 lib/ivy.xml           |  4 ++++
 5 files changed, 19 insertions(+), 7 deletions(-)

diff --git a/.classpath b/.classpath
index e4790ffee3..bb135ac6a9 100644
--- a/.classpath
+++ b/.classpath
@@ -24,6 +24,7 @@ SPDX-License-Identifier: Apache-2.0
 	<classpathentry kind="lib" path="lib/java/build/error_prone_annotations.jar" sourcepath="lib/java-contrib/error_prone_annotations-sources.jar"/>
 	<classpathentry kind="lib" path="lib/java/core/common.jar" sourcepath="lib/java-contrib/common-sources.jar"/>
 	<classpathentry kind="lib" path="lib/java/runtime-smtinterpol/smtinterpol.jar" sourcepath="lib/java-contrib/smtinterpol-sources.jar"/>
+	<classpathentry kind="lib" path="lib/java/runtime-eldarica/eldarica_2.13.jar" sourcepath="lib/java-contrib/eldarica_2.13-sources.jar"/>
 	<classpathentry kind="lib" path="lib/java/runtime-princess/princess_2.13.jar" sourcepath="lib/java-contrib/princess_2.13-sources.jar"/>
 	<classpathentry kind="lib" path="lib/java/runtime-princess/scala-library.jar"/>
 	<classpathentry kind="lib" path="lib/java/runtime-princess/princess-smt-parser_2.13.jar"/>
diff --git a/.idea/JavaSMT.iml b/.idea/JavaSMT.iml
index 7678629575..8846c289c8 100644
--- a/.idea/JavaSMT.iml
+++ b/.idea/JavaSMT.iml
@@ -77,6 +77,7 @@
         <jarDirectory url="file://$MODULE_DIR$/lib/java-contrib" recursive="false" type="SOURCES" />
       </library>
     </orderEntry>
+    <orderEntry type="library" name="runtime-eldarica" level="project" />
   </component>
   <component name="org.twodividedbyzero.idea.findbugs">
     <option name="_basePreferences">
diff --git a/build.xml b/build.xml
index ce0a6c7eca..0dc25ab68f 100644
--- a/build.xml
+++ b/build.xml
@@ -26,6 +26,7 @@ SPDX-License-Identifier: Apache-2.0
         runtime-boolector,
         runtime-cvc4,
         runtime-cvc5,
+        runtime-eldarica,
         runtime-mathsat,
         runtime-opensmt,
         runtime-optimathsat,
@@ -49,7 +50,7 @@ SPDX-License-Identifier: Apache-2.0
     <property name="errorprone.options" value="-Xep:Finally:OFF -Xep:MissingSummary:OFF -Xep:UnescapedEntity:OFF"/>
 
     <!-- Maven Central metadata -->
-    <property name="ivy.pom.description" value="Unified acccess layer to SMT solvers"/>
+    <property name="ivy.pom.description" value="Unified access layer to SMT solvers"/>
     <property name="ivy.pom.url" value="https://github.com/sosy-lab/java-smt"/>
     <property name="ivy.pom.name" value="java-smt"/>
     <property name="ivy.pom.groupId" value="org.sosy-lab"/>
diff --git a/build/ivysettings.xml b/build/ivysettings.xml
index dcec9e40e1..4833706668 100644
--- a/build/ivysettings.xml
+++ b/build/ivysettings.xml
@@ -15,14 +15,19 @@ SPDX-License-Identifier: Apache-2.0
          Keep this file synchronized with
          https://gitlab.com/sosy-lab/software/java-project-template
     -->
-    <settings defaultResolver="Sosy-Lab"/>
+    <settings defaultResolver="chain"/>
     <property name="repo.dir" value="${basedir}/repository"/>
     <resolvers>
-        <!-- Resolver for downloading dependencies -->
-        <url name="Sosy-Lab" descriptor="required">
-            <ivy pattern="${ivy.repo.url}/[organisation]/[module]/ivy-[revision].xml" />
-            <artifact pattern="${ivy.repo.url}/[organisation]/[module]/([arch]/)[artifact]-[revision](-[classifier]).[ext]" />
-        </url>
+        <chain name="chain">
+            <!-- Resolver for downloading dependencies -->
+            <url name="Sosy-Lab" descriptor="required">
+                <ivy pattern="${ivy.repo.url}/[organisation]/[module]/ivy-[revision].xml" />
+                <artifact pattern="${ivy.repo.url}/[organisation]/[module]/([arch]/)[artifact]-[revision](-[classifier]).[ext]" />
+            </url>
+
+            <ibiblio name="local" m2compatible="true" root="https://eldarica.org/maven/"/>
+            <ibiblio name="local" m2compatible="true" root="https://repo1.maven.org/maven2/"/>
+        </chain>
 
         <!-- Resolver for publishing this project -->
         <filesystem name="Sosy-Lab-Publish">
diff --git a/lib/ivy.xml b/lib/ivy.xml
index 7f489b70c2..5e16ce951a 100644
--- a/lib/ivy.xml
+++ b/lib/ivy.xml
@@ -40,6 +40,7 @@ SPDX-License-Identifier: Apache-2.0
         <conf name="runtime-optimathsat" extends="core" description="only one solver included"/>
         <conf name="runtime-smtinterpol" extends="core" description="only one solver included"/>
         <conf name="runtime-princess" extends="core" description="only one solver included"/>
+        <conf name="runtime-eldarica" extends="core" description="only one solver included"/>
         <conf name="runtime-princess-with-javacup" extends="core" description="only one solver included"/>
         <conf name="runtime-z3" extends="runtime-z3-x64,runtime-z3-arm64" description="only one solver included"/>
         <conf name="runtime-z3-x64" extends="core" description="only one solver included"/>
@@ -171,6 +172,9 @@ SPDX-License-Identifier: Apache-2.0
         <!-- SmtInterpol -->
         <dependency org="de.uni-freiburg.informatik.ultimate" name="smtinterpol" rev="2.5-1242-g5c50fb6d" conf="runtime-smtinterpol->master; contrib->sources,javadoc"/>
 
+        <!-- Eldarica -->
+        <dependency org="uuverifiers" name="eldarica_2.13" rev="2.2.1" conf="runtime-eldarica->master; contrib->sources"/>
+
         <!-- Princess and Ostrich for our Maven release -->
         <dependency org="io.github.uuverifiers" name="princess_2.13" rev="2025-11-17" conf="runtime-princess-with-javacup->default; contrib->sources,javadoc"/>
         <dependency org="io.github.uuverifiers" name="ostrich_2.13" rev="2.0" conf="runtime-princess-with-javacup->default; contrib->sources,javadoc"/>

From 8889ec573cc545e64f3808db31af76dd161715d8 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Sun, 26 Apr 2026 17:25:09 +0200
Subject: [PATCH 18/77] eldarica: boolean -> horn converter

---
 .../solvers/eldarica/EldaricaHornProver.java  | 221 ++++++++++++++++++
 .../java_smt/test/EldaricaHornProverTest.java | 181 ++++++++++++++
 2 files changed, 402 insertions(+)
 create mode 100644 src/org/sosy_lab/java_smt/solvers/eldarica/EldaricaHornProver.java
 create mode 100644 src/org/sosy_lab/java_smt/test/EldaricaHornProverTest.java

diff --git a/src/org/sosy_lab/java_smt/solvers/eldarica/EldaricaHornProver.java b/src/org/sosy_lab/java_smt/solvers/eldarica/EldaricaHornProver.java
new file mode 100644
index 0000000000..19a4bb3d5e
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/solvers/eldarica/EldaricaHornProver.java
@@ -0,0 +1,221 @@
+// This file is part of JavaSMT,
+// an API wrapper for a collection of SMT solvers:
+// https://github.com/sosy-lab/java-smt
+//
+// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
+//
+// SPDX-License-Identifier: Apache-2.0
+
+package org.sosy_lab.java_smt.solvers.eldarica;
+
+import ap.api.SimpleAPI;
+import ap.parser.IAtom;
+import ap.parser.IBinFormula;
+import ap.parser.IBinJunctor;
+import ap.parser.IBoolLit;
+import ap.parser.IFormula;
+import ap.parser.IFunApp;
+import ap.parser.IIntFormula;
+import ap.parser.IIntRelation;
+import ap.parser.INot;
+import ap.terfor.preds.Predicate;
+import ap.types.MonoSortedIFunction;
+import com.google.common.base.Preconditions;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import lazabs.horn.HornAPI;
+import lazabs.horn.bottomup.HornClauses.Clause;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.sosy_lab.common.ShutdownNotifier;
+import org.sosy_lab.java_smt.api.BooleanFormula;
+import org.sosy_lab.java_smt.api.ProverEnvironment;
+import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
+import org.sosy_lab.java_smt.api.SolverException;
+import org.sosy_lab.java_smt.solvers.princess.PrincessAbstractProver;
+import org.sosy_lab.java_smt.solvers.princess.PrincessFormulaCreator;
+import org.sosy_lab.java_smt.solvers.princess.PrincessFormulaManager;
+import scala.collection.immutable.List$;
+import scala.jdk.javaapi.CollectionConverters;
+
+public class EldaricaHornProver extends PrincessAbstractProver<Void> implements ProverEnvironment {
+  private final HornAPI horn;
+  private final ArrayList<Clause> clauses = new ArrayList<>();
+
+  public EldaricaHornProver(
+      PrincessFormulaManager pMgr,
+      PrincessFormulaCreator creator,
+      SimpleAPI pApi,
+      ShutdownNotifier pShutdownNotifier,
+      Set<ProverOptions> pOptions) {
+    super(pMgr, creator, pApi, pShutdownNotifier, pOptions);
+    this.horn = new HornAPI(new HornAPI.CEGAROptions()); // TODO: options
+  }
+
+  private static List<IFormula> flatten(final IBinFormula input) {
+    if (input.j() != IBinJunctor.And()) {
+      throw new IllegalArgumentException("Illegal horn clause: " + input);
+    }
+
+    final ArrayList<IFormula> atoms = new ArrayList<>();
+    atoms.addAll(flatten(input.f1()));
+    atoms.addAll(flatten(input.f2()));
+
+    return atoms;
+  }
+
+  private static List<IFormula> flatten(final IFormula input) {
+    if (input instanceof IBinFormula) {
+      return flatten((IBinFormula) input);
+    }
+
+    return List.of(input);
+  }
+
+  private static Clause toClause(final IAtom head, final IFormula rest) {
+    if (rest instanceof IAtom) {
+      return new Clause(head, CollectionConverters.asScala(List.of((IAtom) rest)).toList(),
+          new IBoolLit(true));
+    }
+    if (rest instanceof IIntFormula) {
+      var atom = toAtom((IIntFormula) rest);
+      if (atom != null) {
+        return new Clause(head, CollectionConverters.asScala(List.of(atom)).toList(),
+            new IBoolLit(true));
+      }
+      return new Clause(head, List$.MODULE$.empty(), rest);
+    }
+
+    if (rest instanceof IBinFormula) {
+      List<IAtom> body = new ArrayList<>();
+      IFormula constraint = null;
+
+      for (IFormula and : flatten(rest)) {
+        if (and instanceof IAtom) {
+          body.add((IAtom) and);
+          continue;
+        }
+        if (and instanceof IIntFormula) {
+          var atom = toAtom((IIntFormula) and);
+          if (atom != null) {
+            body.add(atom);
+            continue;
+          }
+        }
+
+        if (constraint != null) {
+          throw new IllegalArgumentException("Duplicated constraints: " + rest);
+        }
+        constraint = and;
+      }
+
+
+      var _constraint = constraint == null ? new IBoolLit(true) : constraint;
+
+      return new Clause(head, CollectionConverters.asScala(body).toList(), _constraint);
+    }
+
+    throw new RuntimeException("TODO");
+  }
+
+
+  @Nullable
+  private static IAtom toAtom(final IIntFormula formula) {
+    if (formula.t() instanceof IFunApp && formula.rel() == IIntRelation.EqZero()) {
+      var t = (IFunApp) formula.t();
+      if (t.fun() instanceof MonoSortedIFunction) {
+        var fun = (MonoSortedIFunction) t.fun();
+        return new IAtom(new Predicate(fun.name(), fun.arity()), t.args());
+      }
+    }
+
+    return null;
+  }
+
+  private static Clause toClause(final IAtom input) {
+    return new Clause(input, List$.MODULE$.empty(), new IBoolLit(true));
+  }
+
+  private static Clause toClause(final IBinFormula input) {
+    if (input.j() != IBinJunctor.Or()) {
+      throw new IllegalArgumentException("Illegal horn clause: " + input);
+    }
+
+    INot not;
+    IFormula other;
+
+
+    if (input.f1() instanceof INot) {
+      not = (INot) input.f1();
+      other = input.f2();
+    } else if (input.f2() instanceof INot) {
+      not = (INot) input.f2();
+      other = input.f1();
+    } else {
+      throw new RuntimeException("TODO");
+    }
+
+    IAtom head;
+
+    if (other instanceof IAtom) {
+      head = (IAtom) other;
+    } else if (other instanceof IIntFormula) {
+      head = toAtom((IIntFormula) other);
+      if (head == null) {
+        throw new RuntimeException("TODO");
+      }
+    } else {
+      throw new RuntimeException("TODO");
+    }
+
+
+    return toClause(head, not.subformula());
+  }
+
+  public static Clause toClause(IFormula input) {
+    if (input instanceof IAtom) {
+      return toClause((IAtom) input);
+    }
+    if (input instanceof IBinFormula) {
+      return toClause((IBinFormula) input);
+    }
+    if (input instanceof IIntFormula) {
+      return toClause(toAtom((IIntFormula) input));
+    }
+
+    throw new IllegalArgumentException("Illegal horn clause: " + input);
+  }
+
+  private void addConstraint1(BooleanFormula constraint) {
+    Preconditions.checkState(!closed);
+
+    final int formulaId = idGenerator.getFreshId();
+    partitions.push(partitions.pop().putAndCopy(formulaId, constraint));
+    api.setPartitionNumber(formulaId);
+
+    final IFormula formula = (IFormula) mgr.extractInfo(constraint);
+    // TODO: purpose?
+    var assertion =
+        api.abbrevSharedExpressions(formula, creator.getEnv().getMinAtomsForAbbreviation());
+
+    if (assertion.isTrue()) {
+      return; // TODO: handle false
+    }
+
+    var clause = toClause(assertion);
+
+    this.clauses.add(clause);
+  }
+
+  @Override
+  @Nullable
+  protected Void addConstraintImpl(BooleanFormula constraint) throws InterruptedException {
+    addConstraint1(constraint);
+    return null;
+  }
+
+  @Override
+  protected boolean isUnsatImpl() throws SolverException {
+    return !this.horn.isSat(CollectionConverters.asScala(this.clauses));
+  }
+}
diff --git a/src/org/sosy_lab/java_smt/test/EldaricaHornProverTest.java b/src/org/sosy_lab/java_smt/test/EldaricaHornProverTest.java
new file mode 100644
index 0000000000..d8a9dae43b
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/EldaricaHornProverTest.java
@@ -0,0 +1,181 @@
+/*
+ * This file is part of JavaSMT,
+ * an API wrapper for a collection of SMT solvers:
+ * https://github.com/sosy-lab/java-smt
+ *
+ * SPDX-FileCopyrightText: 2026 Dirk Beyer <https://www.sosy-lab.org>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.sosy_lab.java_smt.test;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import ap.basetypes.IdealInt;
+import ap.parser.IAtom;
+import ap.parser.IBinFormula;
+import ap.parser.IBinJunctor;
+import ap.parser.IConstant;
+import ap.parser.IFormula;
+import ap.parser.IFunApp;
+import ap.parser.IIntFormula;
+import ap.parser.IIntLit;
+import ap.parser.IIntRelation;
+import ap.parser.INot;
+import ap.parser.IPlus;
+import ap.parser.ITerm;
+import ap.terfor.ConstantTerm;
+import ap.terfor.preds.Predicate;
+import ap.types.MonoSortedIFunction;
+import ap.types.Sort;
+import ap.types.Sort.Integer$;
+import java.util.Arrays;
+import org.junit.Test;
+import org.sosy_lab.java_smt.solvers.eldarica.EldaricaHornProver;
+import scala.collection.immutable.Seq;
+import scala.collection.immutable.Seq$;
+import scala.collection.immutable.Set;
+import scala.jdk.javaapi.CollectionConverters;
+
+public class EldaricaHornProverTest {
+
+  private IAtom atom(String name) {
+    return new IAtom(new Predicate(name, 0), (Seq<ITerm>) Seq$.MODULE$.empty());
+  }
+
+  private <T> Set<T> set(T... values) {
+    return CollectionConverters.asScala(Arrays.asList(values)).toSet();
+  }
+
+  private <T> Seq<T> seq(T... values) {
+    return CollectionConverters.asScala(Arrays.asList(values)).toSeq();
+  }
+
+
+  @Test
+  public void headWithoutBody() {
+    var a = atom("a");
+
+    IFormula input = a;
+
+
+    var clause = EldaricaHornProver.toClause(input);
+
+    assertThat(clause.head()).isEqualTo(a);
+    assertThat(clause.body().toSet()).isEqualTo(set());
+  }
+
+  @Test
+  public void multipleBodyAtomsAndHead() {
+    var a = atom("a");
+    var b = atom("b");
+    var c = atom("c");
+    var d = atom("d");
+
+    IFormula input = new IBinFormula(IBinJunctor.Or(), new INot(new IBinFormula(IBinJunctor.And(),
+        new IBinFormula(IBinJunctor.And(), b, c), d)), a);
+
+
+    var clause = EldaricaHornProver.toClause(input);
+
+    assertThat(clause.head()).isEqualTo(a);
+    assertThat(clause.body().toSet()).isEqualTo(set(b, c, d));
+  }
+
+  @Test
+  public void singleBodyWithHead() {
+    var a = atom("a");
+    var b = atom("b");
+
+
+    IFormula input = new IBinFormula(IBinJunctor.Or(), new INot(b), a);
+
+
+    var clause = EldaricaHornProver.toClause(input);
+
+    assertThat(clause.head()).isEqualTo(a);
+    assertThat(clause.body().toSet()).isEqualTo(set(b));
+  }
+
+  @Test
+  public void predicateHead() {
+    var args = seq((ITerm) new IConstant(new ConstantTerm("x")));
+    var f = new IFunApp(new MonoSortedIFunction("f", seq(Integer$.MODULE$), Sort.Bool(), false,
+        false), args);
+
+    IFormula f0 = new IIntFormula(IIntRelation.EqZero(), f);
+
+
+    var clause = EldaricaHornProver.toClause(f0);
+
+    assertThat(clause.head().toString()).isEqualTo(new IAtom(new Predicate("f", 1), args).toString());
+    assertThat(clause.body().toSet()).isEqualTo(set());
+  }
+
+  @Test
+  public void predicateHeadWithBody() {
+    var args = seq((ITerm) new IConstant(new ConstantTerm("x")));
+    var f = new IFunApp(new MonoSortedIFunction("f", seq(Integer$.MODULE$), Sort.Bool(), false,
+        false), args);
+    var h = new IFunApp(new MonoSortedIFunction("h", seq(Integer$.MODULE$), Sort.Bool(), false,
+        false), args);
+
+    IFormula f0 = new IIntFormula(IIntRelation.EqZero(), f);
+    IFormula h0 = new IIntFormula(IIntRelation.EqZero(), h);
+
+    IFormula input = new IBinFormula(IBinJunctor.Or(), new INot(h0), f0);
+
+
+    var clause = EldaricaHornProver.toClause(input);
+
+    assertThat(clause.head().toString()).isEqualTo(new IAtom(new Predicate("f", 1), args).toString());
+    assertThat(clause.body().toSet().toString()).isEqualTo(set(new IAtom(new Predicate("h", 1),
+        args).toString()).toString());
+  }
+
+  @Test
+  public void constraintWithHeadAndBody() {
+    var a = atom("a");
+    var b = atom("b");
+    var c = atom("c");
+
+
+    IFormula constraint = new IIntFormula(IIntRelation.EqZero(),
+        new IPlus(new IConstant(new ConstantTerm("d")),
+            new IIntLit(IdealInt.apply(-1))));
+
+    IFormula body = new IBinFormula(IBinJunctor.And(), b, c);
+
+    IFormula input = new IBinFormula(IBinJunctor.Or(), new INot(new IBinFormula(IBinJunctor.And(),
+        constraint, body)), a);
+
+
+    var clause = EldaricaHornProver.toClause(input);
+
+    assertThat(clause.head()).isEqualTo(a);
+    assertThat(clause.body().toSet()).isEqualTo(set(b, c));
+    assertThat(clause.constraint()).isEqualTo(constraint);
+  }
+
+  @Test
+  public void constraintWithHead() {
+    var a = atom("a");
+
+
+    IFormula constraint = new IIntFormula(IIntRelation.EqZero(),
+        new IPlus(new IConstant(new ConstantTerm("d")),
+            new IIntLit(IdealInt.apply(-1))));
+
+    IFormula input = new IBinFormula(IBinJunctor.Or(), new INot(constraint), a);
+
+
+    var clause = EldaricaHornProver.toClause(input);
+
+    assertThat(clause.head()).isEqualTo(a);
+    assertThat(clause.body().toSet()).isEqualTo(set());
+    assertThat(clause.constraint()).isEqualTo(constraint);
+  }
+
+  // TODO: no head
+}

From cb3b195d407281ac55fe51e1741c4cc45f818ee7 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Tue, 5 May 2026 16:45:39 +0200
Subject: [PATCH 19/77] HornProverEnvironment

---
 .../java_smt/api/HornProverEnvironment.java   | 14 +++++++
 .../sosy_lab/java_smt/api/SolverContext.java  |  8 ++++
 .../basicimpl/AbstractSolverContext.java      | 13 +++++++
 .../DebuggingHornProverEnvironment.java       | 31 +++++++++++++++
 .../debugging/DebuggingSolverContext.java     |  8 ++++
 .../logging/LoggingHornProverEnvironment.java | 31 +++++++++++++++
 .../logging/LoggingSolverContext.java         |  6 +++
 .../StatisticsHornProverEnvironment.java      | 23 +++++++++++
 .../statistics/StatisticsSolverContext.java   |  7 ++++
 .../SynchronizedHornProverEnvironment.java    | 29 ++++++++++++++
 ...nizedHornProverEnvironmentWithContext.java | 36 +++++++++++++++++
 .../SynchronizedSolverContext.java            | 22 +++++++++++
 .../trace/TraceHornProverEnvironment.java     | 39 +++++++++++++++++++
 .../delegate/trace/TraceSolverContext.java    | 11 ++++++
 14 files changed, 278 insertions(+)
 create mode 100644 src/org/sosy_lab/java_smt/api/HornProverEnvironment.java
 create mode 100644 src/org/sosy_lab/java_smt/delegate/debugging/DebuggingHornProverEnvironment.java
 create mode 100644 src/org/sosy_lab/java_smt/delegate/logging/LoggingHornProverEnvironment.java
 create mode 100644 src/org/sosy_lab/java_smt/delegate/statistics/StatisticsHornProverEnvironment.java
 create mode 100644 src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedHornProverEnvironment.java
 create mode 100644 src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedHornProverEnvironmentWithContext.java
 create mode 100644 src/org/sosy_lab/java_smt/delegate/trace/TraceHornProverEnvironment.java

diff --git a/src/org/sosy_lab/java_smt/api/HornProverEnvironment.java b/src/org/sosy_lab/java_smt/api/HornProverEnvironment.java
new file mode 100644
index 0000000000..baba0fa4f3
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/api/HornProverEnvironment.java
@@ -0,0 +1,14 @@
+// This file is part of JavaSMT,
+// an API wrapper for a collection of SMT solvers:
+// https://github.com/sosy-lab/java-smt
+//
+// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
+//
+// SPDX-License-Identifier: Apache-2.0
+
+package org.sosy_lab.java_smt.api;
+
+
+public interface HornProverEnvironment extends BasicProverEnvironment<Void>, AutoCloseable {
+
+}
diff --git a/src/org/sosy_lab/java_smt/api/SolverContext.java b/src/org/sosy_lab/java_smt/api/SolverContext.java
index 6658e57c9e..11f9be2e3a 100644
--- a/src/org/sosy_lab/java_smt/api/SolverContext.java
+++ b/src/org/sosy_lab/java_smt/api/SolverContext.java
@@ -90,6 +90,14 @@ enum ProverOptions {
    */
   OptimizationProverEnvironment newOptimizationProverEnvironment(ProverOptions... options);
 
+  /**
+   * Create a fresh new {@link HornProverEnvironment} for solving horn clauses.
+   *
+   * @param options Options specified for the prover environment. All the options specified in
+   *     {@link ProverOptions} are turned off by default.
+   */
+  HornProverEnvironment newHornProverEnvironment(ProverOptions... options);
+
   /**
    * Get version information out of the solver.
    *
diff --git a/src/org/sosy_lab/java_smt/basicimpl/AbstractSolverContext.java b/src/org/sosy_lab/java_smt/basicimpl/AbstractSolverContext.java
index f92574f031..6df084a8a5 100644
--- a/src/org/sosy_lab/java_smt/basicimpl/AbstractSolverContext.java
+++ b/src/org/sosy_lab/java_smt/basicimpl/AbstractSolverContext.java
@@ -15,6 +15,7 @@
 import java.util.Set;
 import java.util.function.Consumer;
 import org.sosy_lab.java_smt.api.FormulaManager;
+import org.sosy_lab.java_smt.api.HornProverEnvironment;
 import org.sosy_lab.java_smt.api.InterpolatingProverEnvironment;
 import org.sosy_lab.java_smt.api.OptimizationProverEnvironment;
 import org.sosy_lab.java_smt.api.ProverEnvironment;
@@ -78,6 +79,18 @@ public final OptimizationProverEnvironment newOptimizationProverEnvironment(
   protected abstract OptimizationProverEnvironment newOptimizationProverEnvironment0(
       Set<ProverOptions> pSet);
 
+  @Override
+  public final HornProverEnvironment newHornProverEnvironment(
+      ProverOptions... options) {
+    return newHornProverEnvironment0(toSet(options));
+  }
+
+  protected HornProverEnvironment newHornProverEnvironment0(
+      Set<ProverOptions> pSet) {
+    // TODO: Fallback to normal ProverEnvironment?
+    throw new UnsupportedOperationException("Solver does not support horn clauses");
+  }
+
   /**
    * Whether the solver supports solving under some given assumptions (with all corresponding
    * features) by itself, i.e., whether {@link
diff --git a/src/org/sosy_lab/java_smt/delegate/debugging/DebuggingHornProverEnvironment.java b/src/org/sosy_lab/java_smt/delegate/debugging/DebuggingHornProverEnvironment.java
new file mode 100644
index 0000000000..ec094b154f
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/delegate/debugging/DebuggingHornProverEnvironment.java
@@ -0,0 +1,31 @@
+// This file is part of JavaSMT,
+// an API wrapper for a collection of SMT solvers:
+// https://github.com/sosy-lab/java-smt
+//
+// SPDX-FileCopyrightText: 2024 Dirk Beyer <https://www.sosy-lab.org>
+//
+// SPDX-License-Identifier: Apache-2.0
+
+package org.sosy_lab.java_smt.delegate.debugging;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.Collection;
+import java.util.List;
+import org.sosy_lab.java_smt.api.BooleanFormula;
+import org.sosy_lab.java_smt.api.HornProverEnvironment;
+import org.sosy_lab.java_smt.api.InterpolatingProverEnvironment;
+import org.sosy_lab.java_smt.api.SolverException;
+
+class DebuggingHornProverEnvironment extends DebuggingBasicProverEnvironment<Void>
+    implements HornProverEnvironment {
+  private final HornProverEnvironment delegate;
+  private final DebuggingAssertions debugging;
+
+  DebuggingHornProverEnvironment(
+      HornProverEnvironment pDelegate, DebuggingAssertions pDebugging) {
+    super(pDelegate, pDebugging);
+    delegate = checkNotNull(pDelegate);
+    debugging = pDebugging;
+  }
+}
diff --git a/src/org/sosy_lab/java_smt/delegate/debugging/DebuggingSolverContext.java b/src/org/sosy_lab/java_smt/delegate/debugging/DebuggingSolverContext.java
index e3a95aa069..265136c6e7 100644
--- a/src/org/sosy_lab/java_smt/delegate/debugging/DebuggingSolverContext.java
+++ b/src/org/sosy_lab/java_smt/delegate/debugging/DebuggingSolverContext.java
@@ -15,6 +15,7 @@
 import org.sosy_lab.common.configuration.InvalidConfigurationException;
 import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
 import org.sosy_lab.java_smt.api.FormulaManager;
+import org.sosy_lab.java_smt.api.HornProverEnvironment;
 import org.sosy_lab.java_smt.api.InterpolatingProverEnvironment;
 import org.sosy_lab.java_smt.api.OptimizationProverEnvironment;
 import org.sosy_lab.java_smt.api.ProverEnvironment;
@@ -64,6 +65,13 @@ public OptimizationProverEnvironment newOptimizationProverEnvironment(ProverOpti
         delegate.newOptimizationProverEnvironment(options), debugging);
   }
 
+  @Override
+  public HornProverEnvironment newHornProverEnvironment(ProverOptions... options) {
+    debugging.assertThreadLocal();
+    return new DebuggingHornProverEnvironment(delegate.newHornProverEnvironment(options),
+        debugging);
+  }
+
   @Override
   public String getVersion() {
     debugging.assertThreadLocal();
diff --git a/src/org/sosy_lab/java_smt/delegate/logging/LoggingHornProverEnvironment.java b/src/org/sosy_lab/java_smt/delegate/logging/LoggingHornProverEnvironment.java
new file mode 100644
index 0000000000..8ed635b05b
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/delegate/logging/LoggingHornProverEnvironment.java
@@ -0,0 +1,31 @@
+// This file is part of JavaSMT,
+// an API wrapper for a collection of SMT solvers:
+// https://github.com/sosy-lab/java-smt
+//
+// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
+//
+// SPDX-License-Identifier: Apache-2.0
+
+package org.sosy_lab.java_smt.delegate.logging;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.Optional;
+import java.util.logging.Level;
+import org.sosy_lab.common.log.LogManager;
+import org.sosy_lab.common.rationals.Rational;
+import org.sosy_lab.java_smt.api.Formula;
+import org.sosy_lab.java_smt.api.HornProverEnvironment;
+import org.sosy_lab.java_smt.api.SolverException;
+
+/** Wrapper for a horn solver. */
+class LoggingHornProverEnvironment extends LoggingBasicProverEnvironment<Void>
+    implements HornProverEnvironment {
+
+  private final HornProverEnvironment delegate;
+
+  LoggingHornProverEnvironment(LogManager logger, HornProverEnvironment delegate) {
+    super(delegate, logger);
+    this.delegate = checkNotNull(delegate);
+  }
+}
diff --git a/src/org/sosy_lab/java_smt/delegate/logging/LoggingSolverContext.java b/src/org/sosy_lab/java_smt/delegate/logging/LoggingSolverContext.java
index b68b9e8c5b..388a53241e 100644
--- a/src/org/sosy_lab/java_smt/delegate/logging/LoggingSolverContext.java
+++ b/src/org/sosy_lab/java_smt/delegate/logging/LoggingSolverContext.java
@@ -14,6 +14,7 @@
 import org.sosy_lab.common.log.LogManager;
 import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
 import org.sosy_lab.java_smt.api.FormulaManager;
+import org.sosy_lab.java_smt.api.HornProverEnvironment;
 import org.sosy_lab.java_smt.api.InterpolatingProverEnvironment;
 import org.sosy_lab.java_smt.api.OptimizationProverEnvironment;
 import org.sosy_lab.java_smt.api.ProverEnvironment;
@@ -56,6 +57,11 @@ public OptimizationProverEnvironment newOptimizationProverEnvironment(ProverOpti
         logger, delegate.newOptimizationProverEnvironment(options));
   }
 
+  @Override
+  public HornProverEnvironment newHornProverEnvironment(ProverOptions... options) {
+    return new LoggingHornProverEnvironment(logger, delegate.newHornProverEnvironment(options));
+  }
+
   @Override
   public String getVersion() {
     return delegate.getVersion();
diff --git a/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsHornProverEnvironment.java b/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsHornProverEnvironment.java
new file mode 100644
index 0000000000..12641ee2d1
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsHornProverEnvironment.java
@@ -0,0 +1,23 @@
+// This file is part of JavaSMT,
+// an API wrapper for a collection of SMT solvers:
+// https://github.com/sosy-lab/java-smt
+//
+// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
+//
+// SPDX-License-Identifier: Apache-2.0
+
+package org.sosy_lab.java_smt.delegate.statistics;
+
+import org.sosy_lab.java_smt.api.HornProverEnvironment;
+
+class StatisticsHornProverEnvironment extends StatisticsBasicProverEnvironment<Void>
+    implements HornProverEnvironment {
+
+  private final HornProverEnvironment delegate;
+
+  StatisticsHornProverEnvironment(
+      HornProverEnvironment pDelegate, SolverStatistics pStats) {
+    super(pDelegate, pStats);
+    delegate = pDelegate;
+  }
+}
diff --git a/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsSolverContext.java b/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsSolverContext.java
index 214d2dd576..b47c224cad 100644
--- a/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsSolverContext.java
+++ b/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsSolverContext.java
@@ -14,6 +14,7 @@
 import java.util.Map;
 import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
 import org.sosy_lab.java_smt.api.FormulaManager;
+import org.sosy_lab.java_smt.api.HornProverEnvironment;
 import org.sosy_lab.java_smt.api.InterpolatingProverEnvironment;
 import org.sosy_lab.java_smt.api.OptimizationProverEnvironment;
 import org.sosy_lab.java_smt.api.ProverEnvironment;
@@ -54,6 +55,12 @@ public OptimizationProverEnvironment newOptimizationProverEnvironment(ProverOpti
         delegate.newOptimizationProverEnvironment(pOptions), stats);
   }
 
+  @Override
+  public HornProverEnvironment newHornProverEnvironment(ProverOptions... options) {
+    return new StatisticsHornProverEnvironment(delegate.newHornProverEnvironment(options),
+        stats);
+  }
+
   @Override
   public String getVersion() {
     return delegate.getVersion();
diff --git a/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedHornProverEnvironment.java b/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedHornProverEnvironment.java
new file mode 100644
index 0000000000..09c6efa162
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedHornProverEnvironment.java
@@ -0,0 +1,29 @@
+// This file is part of JavaSMT,
+// an API wrapper for a collection of SMT solvers:
+// https://github.com/sosy-lab/java-smt
+//
+// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
+//
+// SPDX-License-Identifier: Apache-2.0
+
+package org.sosy_lab.java_smt.delegate.synchronize;
+
+import java.util.Collection;
+import java.util.List;
+import org.sosy_lab.java_smt.api.BooleanFormula;
+import org.sosy_lab.java_smt.api.HornProverEnvironment;
+import org.sosy_lab.java_smt.api.InterpolatingProverEnvironment;
+import org.sosy_lab.java_smt.api.SolverContext;
+import org.sosy_lab.java_smt.api.SolverException;
+
+class SynchronizedHornProverEnvironment extends SynchronizedBasicProverEnvironment<Void>
+    implements HornProverEnvironment {
+
+  private final HornProverEnvironment delegate;
+
+  SynchronizedHornProverEnvironment(
+      HornProverEnvironment pDelegate, SolverContext pSync) {
+    super(pDelegate, pSync);
+    delegate = pDelegate;
+  }
+}
diff --git a/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedHornProverEnvironmentWithContext.java b/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedHornProverEnvironmentWithContext.java
new file mode 100644
index 0000000000..79d90b6f48
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedHornProverEnvironmentWithContext.java
@@ -0,0 +1,36 @@
+// This file is part of JavaSMT,
+// an API wrapper for a collection of SMT solvers:
+// https://github.com/sosy-lab/java-smt
+//
+// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
+//
+// SPDX-License-Identifier: Apache-2.0
+
+package org.sosy_lab.java_smt.delegate.synchronize;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.Collection;
+import java.util.List;
+import org.sosy_lab.java_smt.api.BooleanFormula;
+import org.sosy_lab.java_smt.api.FormulaManager;
+import org.sosy_lab.java_smt.api.HornProverEnvironment;
+import org.sosy_lab.java_smt.api.InterpolatingProverEnvironment;
+import org.sosy_lab.java_smt.api.SolverContext;
+import org.sosy_lab.java_smt.api.SolverException;
+
+class SynchronizedHornProverEnvironmentWithContext
+    extends SynchronizedBasicProverEnvironmentWithContext<Void>
+    implements HornProverEnvironment {
+
+  private final HornProverEnvironment delegate;
+
+  SynchronizedHornProverEnvironmentWithContext(
+      HornProverEnvironment pDelegate,
+      SolverContext pSync,
+      FormulaManager pManager,
+      FormulaManager pOtherManager) {
+    super(pDelegate, pSync, pManager, pOtherManager);
+    delegate = checkNotNull(pDelegate);
+  }
+}
diff --git a/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedSolverContext.java b/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedSolverContext.java
index bea5a9fb00..c8ebbcddbe 100644
--- a/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedSolverContext.java
+++ b/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedSolverContext.java
@@ -12,6 +12,7 @@
 
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableMap;
+import lazabs.horn.global.Horn;
 import org.sosy_lab.common.ShutdownNotifier;
 import org.sosy_lab.common.configuration.Configuration;
 import org.sosy_lab.common.configuration.InvalidConfigurationException;
@@ -21,6 +22,7 @@
 import org.sosy_lab.java_smt.SolverContextFactory;
 import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
 import org.sosy_lab.java_smt.api.FormulaManager;
+import org.sosy_lab.java_smt.api.HornProverEnvironment;
 import org.sosy_lab.java_smt.api.InterpolatingProverEnvironment;
 import org.sosy_lab.java_smt.api.OptimizationProverEnvironment;
 import org.sosy_lab.java_smt.api.ProverEnvironment;
@@ -124,6 +126,26 @@ public OptimizationProverEnvironment newOptimizationProverEnvironment(ProverOpti
     }
   }
 
+  @SuppressWarnings("resource")
+  @Override
+  public HornProverEnvironment newHornProverEnvironment(
+      ProverOptions... options) {
+    synchronized (sync) {
+      if (useSeperateProvers) {
+        SolverContext otherContext = createOtherContext();
+        return new SynchronizedHornProverEnvironmentWithContext(
+            otherContext.newHornProverEnvironment(options),
+            sync,
+            delegate.getFormulaManager(),
+            otherContext.getFormulaManager());
+      } else {
+        return new SynchronizedHornProverEnvironment(
+            delegate.newHornProverEnvironment(options), delegate);
+      }
+    }
+  }
+
+
   @Override
   public String getVersion() {
     synchronized (sync) {
diff --git a/src/org/sosy_lab/java_smt/delegate/trace/TraceHornProverEnvironment.java b/src/org/sosy_lab/java_smt/delegate/trace/TraceHornProverEnvironment.java
new file mode 100644
index 0000000000..28302ea209
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/delegate/trace/TraceHornProverEnvironment.java
@@ -0,0 +1,39 @@
+/*
+ * This file is part of JavaSMT,
+ * an API wrapper for a collection of SMT solvers:
+ * https://github.com/sosy-lab/java-smt
+ *
+ * SPDX-FileCopyrightText: 2025 Dirk Beyer <https://www.sosy-lab.org>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.sosy_lab.java_smt.delegate.trace;
+
+import com.google.common.base.Joiner;
+import com.google.common.collect.FluentIterable;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+import org.sosy_lab.java_smt.api.BooleanFormula;
+import org.sosy_lab.java_smt.api.HornProverEnvironment;
+import org.sosy_lab.java_smt.api.InterpolatingProverEnvironment;
+import org.sosy_lab.java_smt.api.SolverException;
+
+class TraceHornProverEnvironment extends TraceBasicProverEnvironment<Void>
+    implements HornProverEnvironment {
+  private final HornProverEnvironment delegate;
+  private final TraceFormulaManager mgr;
+  private final TraceLogger logger;
+
+  TraceHornProverEnvironment(
+      HornProverEnvironment pDelegate,
+      TraceFormulaManager pFormulaManager,
+      TraceLogger pLogger) {
+    super(pDelegate, pFormulaManager, pLogger);
+    delegate = pDelegate;
+    mgr = pFormulaManager;
+    logger = pLogger;
+  }
+}
diff --git a/src/org/sosy_lab/java_smt/delegate/trace/TraceSolverContext.java b/src/org/sosy_lab/java_smt/delegate/trace/TraceSolverContext.java
index 6887dff9dc..5134123b1d 100644
--- a/src/org/sosy_lab/java_smt/delegate/trace/TraceSolverContext.java
+++ b/src/org/sosy_lab/java_smt/delegate/trace/TraceSolverContext.java
@@ -30,6 +30,7 @@
 import org.sosy_lab.common.log.LogManager;
 import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
 import org.sosy_lab.java_smt.api.FormulaManager;
+import org.sosy_lab.java_smt.api.HornProverEnvironment;
 import org.sosy_lab.java_smt.api.InterpolatingProverEnvironment;
 import org.sosy_lab.java_smt.api.OptimizationProverEnvironment;
 import org.sosy_lab.java_smt.api.ProverEnvironment;
@@ -162,6 +163,16 @@ public OptimizationProverEnvironment newOptimizationProverEnvironment(ProverOpti
                 delegate.newOptimizationProverEnvironment(options), mgr, logger));
   }
 
+  @Override
+  public HornProverEnvironment newHornProverEnvironment(ProverOptions... options) {
+    return logger.logDefKeep(
+        "context",
+        "newHornProverEnvironment(%s)".formatted(getOptionsForLogging(options)),
+        () ->
+            new TraceHornProverEnvironment(
+                delegate.newHornProverEnvironment(options), mgr, logger));
+  }
+
   private static String getOptionsForLogging(ProverOptions[] options) {
     return FluentIterable.from(options)
         .transform(v -> "SolverContext.ProverOptions." + v.name())

From 8cd2f12e8ea60683964036215e098afc0b5a4350 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Tue, 5 May 2026 17:24:16 +0200
Subject: [PATCH 20/77] princess: add eldarica as horn prover environment

---
 .../EldaricaHornProver.java                   | 43 ++++++++++---------
 .../princess/PrincessAbstractProver.java      |  2 +-
 .../solvers/princess/PrincessEnvironment.java |  3 ++
 .../princess/PrincessSolverContext.java       | 12 +++++-
 .../java_smt/test/EldaricaHornProverTest.java |  2 +-
 5 files changed, 38 insertions(+), 24 deletions(-)
 rename src/org/sosy_lab/java_smt/solvers/{eldarica => princess}/EldaricaHornProver.java (86%)

diff --git a/src/org/sosy_lab/java_smt/solvers/eldarica/EldaricaHornProver.java b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
similarity index 86%
rename from src/org/sosy_lab/java_smt/solvers/eldarica/EldaricaHornProver.java
rename to src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
index 19a4bb3d5e..d39956ff57 100644
--- a/src/org/sosy_lab/java_smt/solvers/eldarica/EldaricaHornProver.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
@@ -1,12 +1,14 @@
-// This file is part of JavaSMT,
-// an API wrapper for a collection of SMT solvers:
-// https://github.com/sosy-lab/java-smt
-//
-// SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
-//
-// SPDX-License-Identifier: Apache-2.0
-
-package org.sosy_lab.java_smt.solvers.eldarica;
+/*
+ * This file is part of JavaSMT,
+ * an API wrapper for a collection of SMT solvers:
+ * https://github.com/sosy-lab/java-smt
+ *
+ * SPDX-FileCopyrightText: 2026 Dirk Beyer <https://www.sosy-lab.org>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.sosy_lab.java_smt.solvers.princess;
 
 import ap.api.SimpleAPI;
 import ap.parser.IAtom;
@@ -29,16 +31,14 @@
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.sosy_lab.common.ShutdownNotifier;
 import org.sosy_lab.java_smt.api.BooleanFormula;
-import org.sosy_lab.java_smt.api.ProverEnvironment;
+import org.sosy_lab.java_smt.api.HornProverEnvironment;
 import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
 import org.sosy_lab.java_smt.api.SolverException;
-import org.sosy_lab.java_smt.solvers.princess.PrincessAbstractProver;
-import org.sosy_lab.java_smt.solvers.princess.PrincessFormulaCreator;
-import org.sosy_lab.java_smt.solvers.princess.PrincessFormulaManager;
 import scala.collection.immutable.List$;
 import scala.jdk.javaapi.CollectionConverters;
 
-public class EldaricaHornProver extends PrincessAbstractProver<Void> implements ProverEnvironment {
+public class EldaricaHornProver extends PrincessAbstractProver<Void> implements
+                                                                     HornProverEnvironment {
   private final HornAPI horn;
   private final ArrayList<Clause> clauses = new ArrayList<>();
 
@@ -104,7 +104,7 @@ private static Clause toClause(final IAtom head, final IFormula rest) {
         }
 
         if (constraint != null) {
-          throw new IllegalArgumentException("Duplicated constraints: " + rest);
+          throw new IllegalArgumentException("Multiple constraints: " + rest);
         }
         constraint = and;
       }
@@ -121,10 +121,8 @@ private static Clause toClause(final IAtom head, final IFormula rest) {
 
   @Nullable
   private static IAtom toAtom(final IIntFormula formula) {
-    if (formula.t() instanceof IFunApp && formula.rel() == IIntRelation.EqZero()) {
-      var t = (IFunApp) formula.t();
-      if (t.fun() instanceof MonoSortedIFunction) {
-        var fun = (MonoSortedIFunction) t.fun();
+    if (formula.t() instanceof IFunApp t && formula.rel() == IIntRelation.EqZero()) {
+      if (t.fun() instanceof MonoSortedIFunction fun) {
         return new IAtom(new Predicate(fun.name(), fun.arity()), t.args());
       }
     }
@@ -198,8 +196,11 @@ private void addConstraint1(BooleanFormula constraint) {
     var assertion =
         api.abbrevSharedExpressions(formula, creator.getEnv().getMinAtomsForAbbreviation());
 
+    if (assertion.isFalse()) {
+      throw new RuntimeException("TODO: handle false");
+    }
     if (assertion.isTrue()) {
-      return; // TODO: handle false
+      return;
     }
 
     var clause = toClause(assertion);
@@ -218,4 +219,6 @@ protected Void addConstraintImpl(BooleanFormula constraint) throws InterruptedEx
   protected boolean isUnsatImpl() throws SolverException {
     return !this.horn.isSat(CollectionConverters.asScala(this.clauses));
   }
+
+  // TODO: Model, push/pop?.
 }
diff --git a/src/org/sosy_lab/java_smt/solvers/princess/PrincessAbstractProver.java b/src/org/sosy_lab/java_smt/solvers/princess/PrincessAbstractProver.java
index 8a1230a9e4..7b236927be 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/PrincessAbstractProver.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/PrincessAbstractProver.java
@@ -51,7 +51,7 @@ abstract class PrincessAbstractProver<E> extends AbstractProverWithAllSat<E> {
   protected final UniqueIdGenerator idGenerator = new UniqueIdGenerator();
   protected final Deque<PersistentMap<Integer, BooleanFormula>> partitions = new ArrayDeque<>();
 
-  private final PrincessFormulaCreator creator;
+  protected final PrincessFormulaCreator creator;
 
   PrincessAbstractProver(
       PrincessFormulaManager pMgr,
diff --git a/src/org/sosy_lab/java_smt/solvers/princess/PrincessEnvironment.java b/src/org/sosy_lab/java_smt/solvers/princess/PrincessEnvironment.java
index b3a5e937e0..6da08414e6 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/PrincessEnvironment.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/PrincessEnvironment.java
@@ -210,6 +210,7 @@ class PrincessEnvironment {
    */
   PrincessAbstractProver<?> getNewProver(
       boolean useForInterpolation,
+      boolean useForHorn,
       PrincessFormulaManager mgr,
       PrincessFormulaCreator creator,
       Set<ProverOptions> pOptions) {
@@ -225,6 +226,8 @@ PrincessAbstractProver<?> getNewProver(
     PrincessAbstractProver<?> prover;
     if (useForInterpolation) {
       prover = new PrincessInterpolatingProver(mgr, creator, newApi, shutdownNotifier, pOptions);
+    } else if (useForHorn) {
+      prover = new EldaricaHornProver(mgr, creator, newApi, shutdownNotifier, pOptions);
     } else {
       prover = new PrincessTheoremProver(mgr, creator, newApi, shutdownNotifier, pOptions);
     }
diff --git a/src/org/sosy_lab/java_smt/solvers/princess/PrincessSolverContext.java b/src/org/sosy_lab/java_smt/solvers/princess/PrincessSolverContext.java
index 1dbae22be9..16f1331d8b 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/PrincessSolverContext.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/PrincessSolverContext.java
@@ -16,6 +16,7 @@
 import org.sosy_lab.common.configuration.InvalidConfigurationException;
 import org.sosy_lab.common.io.PathCounterTemplate;
 import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
+import org.sosy_lab.java_smt.api.HornProverEnvironment;
 import org.sosy_lab.java_smt.api.InterpolatingProverEnvironment;
 import org.sosy_lab.java_smt.api.OptimizationProverEnvironment;
 import org.sosy_lab.java_smt.api.ProverEnvironment;
@@ -75,7 +76,8 @@ public static SolverContext create(
   @SuppressWarnings("resource")
   @Override
   protected ProverEnvironment newProverEnvironment0(Set<ProverOptions> options) {
-    return (PrincessTheoremProver) creator.getEnv().getNewProver(false, manager, creator, options);
+    return (PrincessTheoremProver) creator.getEnv().getNewProver(false, false,manager, creator,
+        options);
   }
 
   @SuppressWarnings("resource")
@@ -83,7 +85,7 @@ protected ProverEnvironment newProverEnvironment0(Set<ProverOptions> options) {
   protected InterpolatingProverEnvironment<?> newProverEnvironmentWithInterpolation0(
       Set<ProverOptions> options) {
     return (PrincessInterpolatingProver)
-        creator.getEnv().getNewProver(true, manager, creator, options);
+        creator.getEnv().getNewProver(true, false, manager, creator, options);
   }
 
   @Override
@@ -92,6 +94,12 @@ public OptimizationProverEnvironment newOptimizationProverEnvironment0(
     throw new UnsupportedOperationException("Princess does not support optimization");
   }
 
+  @Override
+  protected HornProverEnvironment newHornProverEnvironment0(Set<ProverOptions> options) {
+    return (EldaricaHornProver)
+        creator.getEnv().getNewProver(false, true, manager, creator, options);
+  }
+
   @Override
   public String getVersion() {
     return "Princess " + SimpleAPI.version();
diff --git a/src/org/sosy_lab/java_smt/test/EldaricaHornProverTest.java b/src/org/sosy_lab/java_smt/test/EldaricaHornProverTest.java
index d8a9dae43b..e3382fd634 100644
--- a/src/org/sosy_lab/java_smt/test/EldaricaHornProverTest.java
+++ b/src/org/sosy_lab/java_smt/test/EldaricaHornProverTest.java
@@ -32,7 +32,7 @@
 import ap.types.Sort.Integer$;
 import java.util.Arrays;
 import org.junit.Test;
-import org.sosy_lab.java_smt.solvers.eldarica.EldaricaHornProver;
+import org.sosy_lab.java_smt.solvers.princess.EldaricaHornProver;
 import scala.collection.immutable.Seq;
 import scala.collection.immutable.Seq$;
 import scala.collection.immutable.Set;

From 7625b0a9f56ff88e022ab9ec4e368619967e1aba Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Tue, 5 May 2026 17:25:19 +0200
Subject: [PATCH 21/77] solver context: add eldarica as parser

This is just an alias for `PRINCESS` at the moment, as eldarica builds up on princess and is just the horn prover environment.
---
 src/org/sosy_lab/java_smt/SolverContextFactory.java          | 5 +++--
 src/org/sosy_lab/java_smt/test/SolverContextFactoryTest.java | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/SolverContextFactory.java b/src/org/sosy_lab/java_smt/SolverContextFactory.java
index 5b1caf8616..ab2e4711d7 100644
--- a/src/org/sosy_lab/java_smt/SolverContextFactory.java
+++ b/src/org/sosy_lab/java_smt/SolverContextFactory.java
@@ -63,7 +63,8 @@ public enum Solvers {
     CVC4,
     CVC5,
     YICES2,
-    BITWUZLA
+    BITWUZLA,
+    ELDARICA,
   }
 
   @Option(secure = true, description = "Export solver queries in SmtLib format into a file.")
@@ -310,7 +311,7 @@ private SolverContext generateContext0(Solvers solverToCreate)
               nonLinearArithmetic,
               loader);
 
-      case PRINCESS ->
+      case PRINCESS, ELDARICA ->
           PrincessSolverContext.create(
               config, shutdownNotifier, logfile, (int) randomSeed, nonLinearArithmetic);
 
diff --git a/src/org/sosy_lab/java_smt/test/SolverContextFactoryTest.java b/src/org/sosy_lab/java_smt/test/SolverContextFactoryTest.java
index af8e217497..342ebb4ffa 100644
--- a/src/org/sosy_lab/java_smt/test/SolverContextFactoryTest.java
+++ b/src/org/sosy_lab/java_smt/test/SolverContextFactoryTest.java
@@ -111,7 +111,7 @@ private void requirePlatformNotSupported() {
    */
   private boolean isSupportedOperatingSystemAndArchitecture() {
     return switch (solverToUse()) {
-      case SMTINTERPOL, PRINCESS ->
+      case SMTINTERPOL, PRINCESS, ELDARICA ->
           // Any operating system and any architecture is allowed, Java is sufficient
           true;
       case BOOLECTOR, CVC4 -> IS_LINUX && !IS_ARCH_ARM64;

From 2bb480800f48b6200659f3fc652c74370b84e4ea Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Thu, 14 May 2026 18:27:28 +0200
Subject: [PATCH 22/77] eldarica horn prover: support for quantifiers,
 improvements

This is needed for smtlib2 parsing (and evaluation for me :P)
---
 .../solvers/princess/EldaricaHornProver.java  | 120 +++++++++++++-----
 1 file changed, 87 insertions(+), 33 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
index d39956ff57..cc32e78102 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
@@ -20,6 +20,9 @@
 import ap.parser.IIntFormula;
 import ap.parser.IIntRelation;
 import ap.parser.INot;
+import ap.parser.ISortedQuantified;
+import ap.parser.ITerm;
+import ap.terfor.conjunctions.Quantifier.ALL$;
 import ap.terfor.preds.Predicate;
 import ap.types.MonoSortedIFunction;
 import com.google.common.base.Preconditions;
@@ -27,6 +30,7 @@
 import java.util.List;
 import java.util.Set;
 import lazabs.horn.HornAPI;
+import lazabs.horn.bottomup.HornClauses;
 import lazabs.horn.bottomup.HornClauses.Clause;
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.sosy_lab.common.ShutdownNotifier;
@@ -34,7 +38,9 @@
 import org.sosy_lab.java_smt.api.HornProverEnvironment;
 import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
 import org.sosy_lab.java_smt.api.SolverException;
+import scala.collection.Seq$;
 import scala.collection.immutable.List$;
+import scala.collection.immutable.Seq;
 import scala.jdk.javaapi.CollectionConverters;
 
 public class EldaricaHornProver extends PrincessAbstractProver<Void> implements
@@ -53,10 +59,17 @@ public EldaricaHornProver(
   }
 
   private static List<IFormula> flatten(final IBinFormula input) {
-    if (input.j() != IBinJunctor.And()) {
-      throw new IllegalArgumentException("Illegal horn clause: " + input);
+    if (input.j() == IBinJunctor.And()) {
+      return flattenAnd(input);
+    }
+    if (input.j() == IBinJunctor.Or()) {
+      return flattenOr(input);
     }
 
+    throw new IllegalArgumentException("Illegal horn clause: " + input);
+  }
+
+  private static List<IFormula> flattenAnd(final IBinFormula input) {
     final ArrayList<IFormula> atoms = new ArrayList<>();
     atoms.addAll(flatten(input.f1()));
     atoms.addAll(flatten(input.f2()));
@@ -64,6 +77,12 @@ private static List<IFormula> flatten(final IBinFormula input) {
     return atoms;
   }
 
+  private static List<IFormula> flattenOr(final IBinFormula input) {
+    final ArrayList<IFormula> atoms = new ArrayList<>();
+
+    throw new IllegalArgumentException("Illegal horn clause: " + input);
+  }
+
   private static List<IFormula> flatten(final IFormula input) {
     if (input instanceof IBinFormula) {
       return flatten((IBinFormula) input);
@@ -72,53 +91,74 @@ private static List<IFormula> flatten(final IFormula input) {
     return List.of(input);
   }
 
-  private static Clause toClause(final IAtom head, final IFormula rest) {
-    if (rest instanceof IAtom) {
-      return new Clause(head, CollectionConverters.asScala(List.of((IAtom) rest)).toList(),
+  private static Clause toClause(final IAtom head, final IAtom rest) {
+    return new Clause(head, CollectionConverters.asScala(List.of(rest)).toList(),
+        new IBoolLit(true));
+  }
+
+  private static Clause toClause(final IAtom head, final IIntFormula rest) {
+    var atom = toAtom(rest);
+    if (atom != null) {
+      return new Clause(head, CollectionConverters.asScala(List.of(atom)).toList(),
           new IBoolLit(true));
     }
-    if (rest instanceof IIntFormula) {
-      var atom = toAtom((IIntFormula) rest);
-      if (atom != null) {
-        return new Clause(head, CollectionConverters.asScala(List.of(atom)).toList(),
-            new IBoolLit(true));
-      }
-      return new Clause(head, List$.MODULE$.empty(), rest);
-    }
+    return new Clause(head, List$.MODULE$.empty(), rest);
+  }
 
-    if (rest instanceof IBinFormula) {
-      List<IAtom> body = new ArrayList<>();
-      IFormula constraint = null;
+  private static Clause toClause(final IAtom head, final IBinFormula rest) {
+    List<IAtom> body = new ArrayList<>();
+    IFormula constraint = null;
 
-      for (IFormula and : flatten(rest)) {
-        if (and instanceof IAtom) {
-          body.add((IAtom) and);
+    for (IFormula and : flatten(rest)) {
+      if (and instanceof IAtom) {
+        body.add((IAtom) and);
+        continue;
+      }
+      if (and instanceof IIntFormula) {
+        var atom = toAtom((IIntFormula) and);
+        if (atom != null) {
+          body.add(atom);
           continue;
         }
-        if (and instanceof IIntFormula) {
-          var atom = toAtom((IIntFormula) and);
-          if (atom != null) {
-            body.add(atom);
-            continue;
-          }
-        }
+      }
 
-        if (constraint != null) {
-          throw new IllegalArgumentException("Multiple constraints: " + rest);
-        }
+      if (constraint == null) {
         constraint = and;
+      } else {
+        constraint = new IBinFormula(IBinJunctor.And(), constraint, and);
       }
+    }
+
+
+    var _constraint = constraint == null ? new IBoolLit(true) : constraint;
+
+    return new Clause(head, CollectionConverters.asScala(body).toList(), _constraint);
+  }
 
+  private static Clause toClause(final IAtom head, final IFormula rest, final IFormula constraint) {
+    // INPUT: ((B1 = 0) & C2) ; constraint: C1
+    // CLAUSE: Clause(FALSE, List(B1), (C2 & !C1))
+    var clause = toClause(head, rest);
 
-      var _constraint = constraint == null ? new IBoolLit(true) : constraint;
+    return new Clause(clause.head(), clause.body(), new IBinFormula(IBinJunctor.And(),
+        clause.constraint(), new INot(constraint)));
+  }
+
+  private static Clause toClause(final IAtom head, final IFormula rest) {
+    if (rest instanceof IAtom) {
+      return toClause(head, (IAtom) rest);
+    }
+    if (rest instanceof IIntFormula) {
+      return toClause(head, (IIntFormula) rest);
+    }
 
-      return new Clause(head, CollectionConverters.asScala(body).toList(), _constraint);
+    if (rest instanceof IBinFormula) {
+      return toClause(head, (IBinFormula) rest);
     }
 
     throw new RuntimeException("TODO");
   }
 
-
   @Nullable
   private static IAtom toAtom(final IIntFormula formula) {
     if (formula.t() instanceof IFunApp t && formula.rel() == IIntRelation.EqZero()) {
@@ -134,6 +174,14 @@ private static Clause toClause(final IAtom input) {
     return new Clause(input, List$.MODULE$.empty(), new IBoolLit(true));
   }
 
+  private static Clause toClause(final ISortedQuantified input) {
+    if (input.quan() != ALL$.MODULE$) {
+      throw new IllegalArgumentException("Illegal horn clause: " + input);
+    }
+
+    return toClause(input.subformula());
+  }
+
   private static Clause toClause(final IBinFormula input) {
     if (input.j() != IBinJunctor.Or()) {
       throw new IllegalArgumentException("Illegal horn clause: " + input);
@@ -163,7 +211,8 @@ private static Clause toClause(final IBinFormula input) {
         throw new RuntimeException("TODO");
       }
     } else {
-      throw new RuntimeException("TODO");
+      head = new IAtom(HornClauses.FALSE(), (Seq<ITerm>) Seq$.MODULE$.empty());
+      return toClause(head, not.subformula(), other);
     }
 
 
@@ -171,10 +220,15 @@ private static Clause toClause(final IBinFormula input) {
   }
 
   public static Clause toClause(IFormula input) {
+    if (input instanceof ISortedQuantified) {
+      return toClause((ISortedQuantified) input);
+    }
     if (input instanceof IAtom) {
       return toClause((IAtom) input);
     }
     if (input instanceof IBinFormula) {
+      // (!(((((((((_0 = _8) & (_1 = _9)) & (_2 = _10)) & (_3 = _11)) & (_4 = _12)) & (_5 = _13)) & (_6 = _14)) & (_7 = _15)) & true) | (h1(_15, _14, _13, _12, _11, _10, _9, _8, _7, _6, _5, _4, _3, _2, _1, _0) = 0))
+      // Clause(h1(P15, P14, P13, P12, P11, P10, P9, P8, P7, P6, P5, P4, P3, P2, P1, P0),List(),((((((((P0 = P8) & (P1 = P9)) & (P2 = P10)) & (P3 = P11)) & (P4 = P12)) & (P5 = P13)) & (P6 = P14)) & (P7 = P15)))
       return toClause((IBinFormula) input);
     }
     if (input instanceof IIntFormula) {

From 3518963cdab9772280318a68ae76553a2123137a Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Thu, 14 May 2026 18:28:11 +0200
Subject: [PATCH 23/77] intellij classpath fixes

ported over from master
---
 .idea/JavaSMT.iml | 400 +++++++---------------------------------------
 lib/ivy.xml       |   3 -
 2 files changed, 55 insertions(+), 348 deletions(-)

diff --git a/.idea/JavaSMT.iml b/.idea/JavaSMT.iml
index bb237d5c8c..d07b1f5aa1 100644
--- a/.idea/JavaSMT.iml
+++ b/.idea/JavaSMT.iml
@@ -1,373 +1,83 @@
 <?xml version="1.0" encoding="UTF-8"?>
-
-<!--
-This file is part of JavaSMT,
-an API wrapper for a collection of SMT solvers:
-https://github.com/sosy-lab/java-smt
-
-SPDX-FileCopyrightText: 2020 Dirk Beyer <https://www.sosy-lab.org>
-
-SPDX-License-Identifier: Apache-2.0
--->
-
 <module type="JAVA_MODULE" version="4">
   <component name="NewModuleRootManager">
     <output url="file://$MODULE_DIR$/bin" />
     <exclude-output />
+    <javadoc-paths>
+      <root url="jar://$MODULE_DIR$/lib/java-contrib/bitwuzla-javadoc.jar!/" />
+      <root url="jar://$MODULE_DIR$/lib/java-contrib/com.microsoft.z3-javadoc.jar!/" />
+      <root url="jar://$MODULE_DIR$/lib/java-contrib/CVC4-javadoc.jar!/" />
+      <root url="jar://$MODULE_DIR$/lib/java-contrib/cvc5-javadoc.jar!/" />
+      <root url="jar://$MODULE_DIR$/lib/java-contrib/javasmt-yices2-javadoc.jar!/" />
+      <root url="jar://$MODULE_DIR$/lib/java-contrib/opensmt-javadoc.jar!/" />
+      <root url="jar://$MODULE_DIR$/lib/java-contrib/ostrich_2.13-javadoc.jar!/" />
+      <root url="jar://$MODULE_DIR$/lib/java-contrib/princess_2.13-javadoc.jar!/" />
+      <root url="jar://$MODULE_DIR$/lib/java-contrib/smtinterpol-javadoc.jar!/" />
+      <root url="jar://$MODULE_DIR$/lib/java-contrib/yices-javadoc.jar!/" />
+    </javadoc-paths>
     <content url="file://$MODULE_DIR$">
       <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
-      <sourceFolder url="file://$MODULE_DIR$/.apt-generated" isTestSource="false" />
       <excludeFolder url="file://$MODULE_DIR$/JUnit-coverage" />
       <excludeFolder url="file://$MODULE_DIR$/Javadoc" />
       <excludeFolder url="file://$MODULE_DIR$/junit" />
       <excludeFolder url="file://$MODULE_DIR$/repository" />
     </content>
-    <orderEntry type="jdk" jdkName="11" jdkType="JavaSDK" />
+    <orderEntry type="jdk" jdkName="17" jdkType="JavaSDK" />
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="module-library">
       <library>
         <CLASSES>
-          <root url="file://$MODULE_DIR$/lib" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES>
-          <root url="file://$MODULE_DIR$/lib" />
-        </SOURCES>
-        <jarDirectory url="file://$MODULE_DIR$/lib" recursive="false" />
-        <jarDirectory url="file://$MODULE_DIR$/lib" recursive="false" type="SOURCES" />
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/core/guava.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES>
-          <root url="jar://$MODULE_DIR$/lib/java-contrib/guava-sources.jar!/" />
-        </SOURCES>
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/test/checker-compat-qual.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES />
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/test/diffutils.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES />
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/core/common.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES>
-          <root url="jar://$MODULE_DIR$/lib/java-contrib/common-sources.jar!/" />
-        </SOURCES>
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/build/auto-value-annotations.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES>
-          <root url="jar://$MODULE_DIR$/lib/java/build/auto-value-annotations.jar!/" />
-        </SOURCES>
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/test/jsr305.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES>
-          <root url="jar://$MODULE_DIR$/lib/java/test/jsr305.jar!/" />
-        </SOURCES>
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/test/junit.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES />
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/test/guava-testlib.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES>
-          <root url="jar://$MODULE_DIR$/lib/java-contrib/guava-testlib-sources.jar!/" />
-        </SOURCES>
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/test/truth.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES>
-          <root url="jar://$MODULE_DIR$/lib/java-contrib/truth-sources.jar!/" />
-        </SOURCES>
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/core/checker-qual.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES>
-          <root url="jar://$MODULE_DIR$/lib/java-contrib/checker-qual-sources.jar!/" />
-        </SOURCES>
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/core/spotbugs-annotations.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES>
-          <root url="jar://$MODULE_DIR$/lib/java-contrib/spotbugs-annotations-sources.jar!/" />
-        </SOURCES>
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/core/spotbugs-annotations.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES>
-          <root url="jar://$MODULE_DIR$/lib/java-contrib/spotbugs-annotations-sources.jar!/" />
-        </SOURCES>
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/test/truth-java8-extension.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES>
-          <root url="jar://$MODULE_DIR$/lib/java-contrib/truth-java8-extension-sources.jar!/" />
-        </SOURCES>
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
+          <root url="file://$MODULE_DIR$/lib/java/core" />
+          <root url="file://$MODULE_DIR$/lib/java/build" />
+          <root url="file://$MODULE_DIR$/lib/java/test" />
+          <root url="jar://$MODULE_DIR$/lib/java/runtime-bitwuzla/bitwuzla.jar!/" />
+          <root url="jar://$MODULE_DIR$/lib/java/runtime-opensmt/opensmt.jar!/" />
           <root url="jar://$MODULE_DIR$/lib/java/runtime-smtinterpol/smtinterpol.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES>
-          <root url="jar://$MODULE_DIR$/lib/java-contrib/smtinterpol-sources.zip!/SMTInterpol/DeltaDebugger/src" />
-          <root url="jar://$MODULE_DIR$/lib/java-contrib/smtinterpol-sources.zip!/SMTInterpol/Library-SMTLIB/src" />
-          <root url="jar://$MODULE_DIR$/lib/java-contrib/smtinterpol-sources.zip!/SMTInterpol/ProoftreeCheck/src" />
-          <root url="jar://$MODULE_DIR$/lib/java-contrib/smtinterpol-sources.zip!/SMTInterpol/SMTInterpol/src" />
-          <root url="jar://$MODULE_DIR$/lib/java-contrib/smtinterpol-sources.zip!/SMTInterpol/SMTInterpolSamples/src" />
-          <root url="jar://$MODULE_DIR$/lib/java-contrib/smtinterpol-sources.zip!/SMTInterpol/SMTInterpolTest/src" />
-        </SOURCES>
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/java/runtime-princess/scala-library.jar!/" />
+          <root url="jar://$MODULE_DIR$/lib/java/runtime-princess/princess-smt-parser_2.13.jar!/" />
           <root url="jar://$MODULE_DIR$/lib/java/runtime-princess/princess_2.13.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES>
-          <root url="jar://$MODULE_DIR$/lib/java-contrib/princess_2.13-sources.zip!/" />
-        </SOURCES>
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
           <root url="jar://$MODULE_DIR$/lib/java/runtime-princess/princess-parser_2.13.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES />
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/runtime-princess/princess-smt-parser_2.13.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES />
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/runtime-princess/scala-library.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES />
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/runtime-princess/java-cup-runtime.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES />
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/test/hamcrest-core.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES />
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/build/error_prone_annotations.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES />
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/build/error_prone_ant.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES>
-          <root url="jar://$MODULE_DIR$/lib/java/build/error_prone_ant.jar!/" />
-        </SOURCES>
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/runtime/java-cup-runtime.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES />
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/runtime-princess/smt-parser.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES />
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/runtime-z3/com.microsoft.z3.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES>
-          <root url="jar://$MODULE_DIR$/lib/java-contrib/com.microsoft.z3-sources.jar!/" />
-        </SOURCES>
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/runtime-z3-legacy/com.microsoft.z3legacy.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES />
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/runtime-cvc4/CVC4.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES />
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/java/runtime-princess/sourcecode_2.13.jar!/" />
+          <root url="jar://$MODULE_DIR$/lib/java/runtime-princess/org.sat4j.core.jar!/" />
+          <root url="jar://$MODULE_DIR$/lib/java/runtime-eldarica/eldarica_2.13.jar!/" />
           <root url="jar://$MODULE_DIR$/lib/java/runtime-cvc5/cvc5.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES />
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/runtime-opensmt/opensmt.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES />
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/runtime-bitwuzla/bitwuzla.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES />
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/lib/java/runtime-bitwuzla/bitwuzla.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES />
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
           <root url="jar://$MODULE_DIR$/lib/java/runtime-princess/ostrich_2.13.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES />
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/java/runtime-princess/scala-parser-combinators_2.13.jar!/" />
+          <root url="jar://$MODULE_DIR$/lib/java/runtime-princess/ostrich-ecma2020-parser_2.13.jar!/" />
+          <root url="jar://$MODULE_DIR$/lib/java/runtime-princess/geny_2.13.jar!/" />
+          <root url="jar://$MODULE_DIR$/lib/java/runtime-princess/fastparse_2.13.jar!/" />
+          <root url="jar://$MODULE_DIR$/lib/java/runtime-cvc4/CVC4.jar!/" />
+          <root url="jar://$MODULE_DIR$/lib/java/runtime-z3/com.microsoft.z3.jar!/" />
+          <root url="jar://$MODULE_DIR$/lib/java/runtime-z3-legacy/com.microsoft.z3legacy.jar!/" />
+          <root url="jar://$MODULE_DIR$/lib/java/runtime-yices2/yices.jar!/" />
           <root url="jar://$MODULE_DIR$/lib/java/runtime-princess/automaton.jar!/" />
+          <root url="jar://$MODULE_DIR$/lib/java/runtime-princess/java-cup-runtime.jar!/" />
         </CLASSES>
-        <JAVADOC />
-        <SOURCES />
+        <JAVADOC>
+          <root url="file://$MODULE_DIR$/lib/java-contrib" />
+        </JAVADOC>
+        <NATIVE>
+          <root url="file://$MODULE_DIR$/lib/java/runtime-z3" />
+          <root url="file://$MODULE_DIR$/lib/java/runtime-bitwuzla" />
+          <root url="file://$MODULE_DIR$/lib/java/runtime-boolector" />
+          <root url="file://$MODULE_DIR$/lib/java/runtime-mathsat" />
+          <root url="file://$MODULE_DIR$/lib/java/runtime-optimathsat" />
+          <root url="file://$MODULE_DIR$/lib/java/runtime-opensmt" />
+          <root url="file://$MODULE_DIR$/lib/java/runtime-cvc4" />
+          <root url="file://$MODULE_DIR$/lib/java/runtime-cvc5" />
+          <root url="file://$MODULE_DIR$/lib/java/runtime-z3-legacy" />
+          <root url="file://$MODULE_DIR$/lib/java/runtime-yices2" />
+        </NATIVE>
+        <SOURCES>
+          <root url="file://$MODULE_DIR$/lib/java-contrib" />
+        </SOURCES>
+        <jarDirectory url="file://$MODULE_DIR$/lib/java/build" recursive="false" />
+        <jarDirectory url="file://$MODULE_DIR$/lib/java/core" recursive="false" />
+        <jarDirectory url="file://$MODULE_DIR$/lib/java/test" recursive="false" />
+        <jarDirectory url="file://$MODULE_DIR$/lib/java-contrib" recursive="false" type="JAVADOC" />
+        <jarDirectory url="file://$MODULE_DIR$/lib/java-contrib" recursive="false" type="SOURCES" />
       </library>
     </orderEntry>
-    <orderEntry type="library" name="runtime-eldarica" level="project" />
   </component>
   <component name="org.twodividedbyzero.idea.findbugs">
     <option name="_basePreferences">
diff --git a/lib/ivy.xml b/lib/ivy.xml
index a453b49019..5e16ce951a 100644
--- a/lib/ivy.xml
+++ b/lib/ivy.xml
@@ -175,9 +175,6 @@ SPDX-License-Identifier: Apache-2.0
         <!-- Eldarica -->
         <dependency org="uuverifiers" name="eldarica_2.13" rev="2.2.1" conf="runtime-eldarica->master; contrib->sources"/>
 
-        <!-- Eldarica -->
-        <dependency org="uuverifiers" name="eldarica_2.13" rev="2.2.1" conf="runtime-eldarica->master; contrib->sources"/>
-
         <!-- Princess and Ostrich for our Maven release -->
         <dependency org="io.github.uuverifiers" name="princess_2.13" rev="2025-11-17" conf="runtime-princess-with-javacup->default; contrib->sources,javadoc"/>
         <dependency org="io.github.uuverifiers" name="ostrich_2.13" rev="2.0" conf="runtime-princess-with-javacup->default; contrib->sources,javadoc"/>

From 7aaf6a9b4b781b7e6e065e282a9674a14b62320a Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Tue, 19 May 2026 22:11:18 +0200
Subject: [PATCH 24/77] eldarica: split horn converter from horn prover,
 deduplicate predicates

---
 .../solvers/princess/EldaricaHornProver.java  | 192 +-------------
 .../eldarica/PrincessHornConverter.java       | 237 ++++++++++++++++++
 2 files changed, 245 insertions(+), 184 deletions(-)
 create mode 100644 src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
index cc32e78102..11d054a0e1 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
@@ -38,15 +38,14 @@
 import org.sosy_lab.java_smt.api.HornProverEnvironment;
 import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
 import org.sosy_lab.java_smt.api.SolverException;
-import scala.collection.Seq$;
-import scala.collection.immutable.List$;
-import scala.collection.immutable.Seq;
+import org.sosy_lab.java_smt.solvers.princess.eldarica.PrincessHornConverter;
 import scala.jdk.javaapi.CollectionConverters;
 
 public class EldaricaHornProver extends PrincessAbstractProver<Void> implements
                                                                      HornProverEnvironment {
   private final HornAPI horn;
   private final ArrayList<Clause> clauses = new ArrayList<>();
+  private final PrincessHornConverter converter = new PrincessHornConverter();
 
   public EldaricaHornProver(
       PrincessFormulaManager pMgr,
@@ -58,186 +57,6 @@ public EldaricaHornProver(
     this.horn = new HornAPI(new HornAPI.CEGAROptions()); // TODO: options
   }
 
-  private static List<IFormula> flatten(final IBinFormula input) {
-    if (input.j() == IBinJunctor.And()) {
-      return flattenAnd(input);
-    }
-    if (input.j() == IBinJunctor.Or()) {
-      return flattenOr(input);
-    }
-
-    throw new IllegalArgumentException("Illegal horn clause: " + input);
-  }
-
-  private static List<IFormula> flattenAnd(final IBinFormula input) {
-    final ArrayList<IFormula> atoms = new ArrayList<>();
-    atoms.addAll(flatten(input.f1()));
-    atoms.addAll(flatten(input.f2()));
-
-    return atoms;
-  }
-
-  private static List<IFormula> flattenOr(final IBinFormula input) {
-    final ArrayList<IFormula> atoms = new ArrayList<>();
-
-    throw new IllegalArgumentException("Illegal horn clause: " + input);
-  }
-
-  private static List<IFormula> flatten(final IFormula input) {
-    if (input instanceof IBinFormula) {
-      return flatten((IBinFormula) input);
-    }
-
-    return List.of(input);
-  }
-
-  private static Clause toClause(final IAtom head, final IAtom rest) {
-    return new Clause(head, CollectionConverters.asScala(List.of(rest)).toList(),
-        new IBoolLit(true));
-  }
-
-  private static Clause toClause(final IAtom head, final IIntFormula rest) {
-    var atom = toAtom(rest);
-    if (atom != null) {
-      return new Clause(head, CollectionConverters.asScala(List.of(atom)).toList(),
-          new IBoolLit(true));
-    }
-    return new Clause(head, List$.MODULE$.empty(), rest);
-  }
-
-  private static Clause toClause(final IAtom head, final IBinFormula rest) {
-    List<IAtom> body = new ArrayList<>();
-    IFormula constraint = null;
-
-    for (IFormula and : flatten(rest)) {
-      if (and instanceof IAtom) {
-        body.add((IAtom) and);
-        continue;
-      }
-      if (and instanceof IIntFormula) {
-        var atom = toAtom((IIntFormula) and);
-        if (atom != null) {
-          body.add(atom);
-          continue;
-        }
-      }
-
-      if (constraint == null) {
-        constraint = and;
-      } else {
-        constraint = new IBinFormula(IBinJunctor.And(), constraint, and);
-      }
-    }
-
-
-    var _constraint = constraint == null ? new IBoolLit(true) : constraint;
-
-    return new Clause(head, CollectionConverters.asScala(body).toList(), _constraint);
-  }
-
-  private static Clause toClause(final IAtom head, final IFormula rest, final IFormula constraint) {
-    // INPUT: ((B1 = 0) & C2) ; constraint: C1
-    // CLAUSE: Clause(FALSE, List(B1), (C2 & !C1))
-    var clause = toClause(head, rest);
-
-    return new Clause(clause.head(), clause.body(), new IBinFormula(IBinJunctor.And(),
-        clause.constraint(), new INot(constraint)));
-  }
-
-  private static Clause toClause(final IAtom head, final IFormula rest) {
-    if (rest instanceof IAtom) {
-      return toClause(head, (IAtom) rest);
-    }
-    if (rest instanceof IIntFormula) {
-      return toClause(head, (IIntFormula) rest);
-    }
-
-    if (rest instanceof IBinFormula) {
-      return toClause(head, (IBinFormula) rest);
-    }
-
-    throw new RuntimeException("TODO");
-  }
-
-  @Nullable
-  private static IAtom toAtom(final IIntFormula formula) {
-    if (formula.t() instanceof IFunApp t && formula.rel() == IIntRelation.EqZero()) {
-      if (t.fun() instanceof MonoSortedIFunction fun) {
-        return new IAtom(new Predicate(fun.name(), fun.arity()), t.args());
-      }
-    }
-
-    return null;
-  }
-
-  private static Clause toClause(final IAtom input) {
-    return new Clause(input, List$.MODULE$.empty(), new IBoolLit(true));
-  }
-
-  private static Clause toClause(final ISortedQuantified input) {
-    if (input.quan() != ALL$.MODULE$) {
-      throw new IllegalArgumentException("Illegal horn clause: " + input);
-    }
-
-    return toClause(input.subformula());
-  }
-
-  private static Clause toClause(final IBinFormula input) {
-    if (input.j() != IBinJunctor.Or()) {
-      throw new IllegalArgumentException("Illegal horn clause: " + input);
-    }
-
-    INot not;
-    IFormula other;
-
-
-    if (input.f1() instanceof INot) {
-      not = (INot) input.f1();
-      other = input.f2();
-    } else if (input.f2() instanceof INot) {
-      not = (INot) input.f2();
-      other = input.f1();
-    } else {
-      throw new RuntimeException("TODO");
-    }
-
-    IAtom head;
-
-    if (other instanceof IAtom) {
-      head = (IAtom) other;
-    } else if (other instanceof IIntFormula) {
-      head = toAtom((IIntFormula) other);
-      if (head == null) {
-        throw new RuntimeException("TODO");
-      }
-    } else {
-      head = new IAtom(HornClauses.FALSE(), (Seq<ITerm>) Seq$.MODULE$.empty());
-      return toClause(head, not.subformula(), other);
-    }
-
-
-    return toClause(head, not.subformula());
-  }
-
-  public static Clause toClause(IFormula input) {
-    if (input instanceof ISortedQuantified) {
-      return toClause((ISortedQuantified) input);
-    }
-    if (input instanceof IAtom) {
-      return toClause((IAtom) input);
-    }
-    if (input instanceof IBinFormula) {
-      // (!(((((((((_0 = _8) & (_1 = _9)) & (_2 = _10)) & (_3 = _11)) & (_4 = _12)) & (_5 = _13)) & (_6 = _14)) & (_7 = _15)) & true) | (h1(_15, _14, _13, _12, _11, _10, _9, _8, _7, _6, _5, _4, _3, _2, _1, _0) = 0))
-      // Clause(h1(P15, P14, P13, P12, P11, P10, P9, P8, P7, P6, P5, P4, P3, P2, P1, P0),List(),((((((((P0 = P8) & (P1 = P9)) & (P2 = P10)) & (P3 = P11)) & (P4 = P12)) & (P5 = P13)) & (P6 = P14)) & (P7 = P15)))
-      return toClause((IBinFormula) input);
-    }
-    if (input instanceof IIntFormula) {
-      return toClause(toAtom((IIntFormula) input));
-    }
-
-    throw new IllegalArgumentException("Illegal horn clause: " + input);
-  }
-
   private void addConstraint1(BooleanFormula constraint) {
     Preconditions.checkState(!closed);
 
@@ -257,7 +76,12 @@ private void addConstraint1(BooleanFormula constraint) {
       return;
     }
 
-    var clause = toClause(assertion);
+    var clause = converter.toClause(assertion);
+
+    clause.constants();
+    clause.constants();
+    clause.constants();
+    clause.constants();
 
     this.clauses.add(clause);
   }
diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
new file mode 100644
index 0000000000..c3aabf9e07
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -0,0 +1,237 @@
+/*
+ * This file is part of JavaSMT,
+ * an API wrapper for a collection of SMT solvers:
+ * https://github.com/sosy-lab/java-smt
+ *
+ * SPDX-FileCopyrightText: 2026 Dirk Beyer <https://www.sosy-lab.org>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.sosy_lab.java_smt.solvers.princess.eldarica;
+
+import ap.parser.IAtom;
+import ap.parser.IBinFormula;
+import ap.parser.IBinJunctor;
+import ap.parser.IBoolLit;
+import ap.parser.IFormula;
+import ap.parser.IFunApp;
+import ap.parser.IIntFormula;
+import ap.parser.IIntRelation;
+import ap.parser.INot;
+import ap.parser.ISortedQuantified;
+import ap.parser.ITerm;
+import ap.terfor.conjunctions.Quantifier.ALL$;
+import ap.terfor.preds.Predicate;
+import ap.types.MonoSortedIFunction;
+import java.util.ArrayList;
+import java.util.List;
+import lazabs.horn.bottomup.HornClauses;
+import lazabs.horn.bottomup.HornClauses.Clause;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import scala.collection.Seq$;
+import scala.collection.immutable.List$;
+import scala.collection.immutable.Seq;
+import scala.jdk.javaapi.CollectionConverters;
+
+public class PrincessHornConverter {
+  private final ArrayList<Predicate> predicates = new ArrayList<>();
+
+  private Predicate toPredicate(final MonoSortedIFunction function) {
+    // Predicate does not implement hashCode nor equals, this deduplicates the objects. Not 100%
+    // sure if that is needed
+    for (Predicate predicate : this.predicates) {
+      if (!predicate.name().equals(function.name()) || predicate.arity() != function.arity()) {
+        continue;
+      }
+      return predicate;
+    }
+    Predicate predicate = new Predicate(function.name(), function.arity());
+    this.predicates.add(predicate);
+
+    return predicate;
+  }
+
+  private List<IFormula> flatten(final IBinFormula input) {
+    if (input.j() == IBinJunctor.And()) {
+      return flattenAnd(input);
+    }
+    if (input.j() == IBinJunctor.Or()) {
+      return flattenOr(input);
+    }
+
+    throw new IllegalArgumentException("Illegal horn clause: " + input);
+  }
+
+  private List<IFormula> flattenAnd(final IBinFormula input) {
+    final ArrayList<IFormula> atoms = new ArrayList<>();
+    atoms.addAll(flatten(input.f1()));
+    atoms.addAll(flatten(input.f2()));
+
+    return atoms;
+  }
+
+  private List<IFormula> flattenOr(final IBinFormula input) {
+    final ArrayList<IFormula> atoms = new ArrayList<>();
+
+    throw new IllegalArgumentException("Illegal horn clause: " + input);
+  }
+
+  private List<IFormula> flatten(final IFormula input) {
+    if (input instanceof IBinFormula) {
+      return flatten((IBinFormula) input);
+    }
+
+    return List.of(input);
+  }
+
+  private Clause toClause(final IAtom head, final IAtom rest) {
+    return new Clause(head, CollectionConverters.asScala(List.of(rest)).toList(),
+        new IBoolLit(true));
+  }
+
+  private Clause toClause(final IAtom head, final IIntFormula rest) {
+    var atom = toAtom(rest);
+    if (atom != null) {
+      return new Clause(head, CollectionConverters.asScala(List.of(atom)).toList(),
+          new IBoolLit(true));
+    }
+    return new Clause(head, List$.MODULE$.empty(), rest);
+  }
+
+  private Clause toClause(final IAtom head, final IBinFormula rest) {
+    List<IAtom> body = new ArrayList<>();
+    IFormula constraint = null;
+
+    for (IFormula and : flatten(rest)) {
+      if (and instanceof IAtom) {
+        body.add((IAtom) and);
+        continue;
+      }
+      if (and instanceof IIntFormula) {
+        var atom = toAtom((IIntFormula) and);
+        if (atom != null) {
+          body.add(atom);
+          continue;
+        }
+      }
+
+      if (constraint == null) {
+        constraint = and;
+      } else {
+        constraint = new IBinFormula(IBinJunctor.And(), constraint, and);
+      }
+    }
+
+
+    var _constraint = constraint == null ? new IBoolLit(true) : constraint;
+
+    return new Clause(head, CollectionConverters.asScala(body).toList(), _constraint);
+  }
+
+  private Clause toClause(final IAtom head, final IFormula rest, final IFormula constraint) {
+    // INPUT: ((B1 = 0) & C2) ; constraint: C1
+    // CLAUSE: Clause(FALSE, List(B1), (C2 & !C1))
+    var clause = toClause(head, rest);
+
+    return new Clause(clause.head(), clause.body(), new IBinFormula(IBinJunctor.And(),
+        clause.constraint(), new INot(constraint)));
+  }
+
+  private Clause toClause(final IAtom head, final IFormula rest) {
+    if (rest instanceof IAtom) {
+      return toClause(head, (IAtom) rest);
+    }
+    if (rest instanceof IIntFormula) {
+      return toClause(head, (IIntFormula) rest);
+    }
+
+    if (rest instanceof IBinFormula) {
+      return toClause(head, (IBinFormula) rest);
+    }
+
+    throw new RuntimeException("TODO");
+  }
+
+  @Nullable
+  private IAtom toAtom(final IIntFormula formula) {
+    if (formula.t() instanceof IFunApp t && formula.rel() == IIntRelation.EqZero()) {
+      if (t.fun() instanceof MonoSortedIFunction fun) {
+        return new IAtom(toPredicate(fun), t.args());
+      }
+    }
+
+    return null;
+  }
+
+  private Clause toClause(final IAtom input) {
+    return new Clause(input, List$.MODULE$.empty(), new IBoolLit(true));
+  }
+
+  private Clause toClause(final ISortedQuantified input) {
+    if (input.quan() != ALL$.MODULE$) {
+      throw new IllegalArgumentException("Illegal horn clause: " + input);
+    }
+
+    return toClause(input.subformula());
+  }
+
+  private Clause toClause(final IBinFormula input) {
+    if (input.j() != IBinJunctor.Or()) {
+      throw new IllegalArgumentException("Illegal horn clause: " + input);
+    }
+
+    INot not;
+    IFormula other;
+
+
+    if (input.f1() instanceof INot) {
+      not = (INot) input.f1();
+      other = input.f2();
+    } else if (input.f2() instanceof INot) {
+      not = (INot) input.f2();
+      other = input.f1();
+    } else {
+      throw new RuntimeException("TODO");
+    }
+
+    IAtom head;
+
+    if (other instanceof IAtom) {
+      head = (IAtom) other;
+    } else if (other instanceof IIntFormula) {
+      head = toAtom((IIntFormula) other);
+      if (head == null) {
+        throw new RuntimeException("TODO");
+      }
+    } else {
+      head = new IAtom(HornClauses.FALSE(), (Seq<ITerm>) Seq$.MODULE$.empty());
+
+      // TODO: (expected) Clause(FALSE,List(mc(P1, P0)),!(!((101 + -1 * P1) >= 0) | (P0 = 92)))
+      // TODO: (actual  ) Clause(FALSE,List(mc(P1, P0)),(((101 + -1 * P1) >= 0) & !(P0 = 91)))
+      return toClause(head, not.subformula(), other);
+    }
+
+
+    return toClause(head, not.subformula());
+  }
+
+  public Clause toClause(IFormula input) {
+    if (input instanceof ISortedQuantified) {
+      return toClause((ISortedQuantified) input);
+    }
+    if (input instanceof IAtom) {
+      return toClause((IAtom) input);
+    }
+    if (input instanceof IBinFormula) {
+      // (!(((((((((_0 = _8) & (_1 = _9)) & (_2 = _10)) & (_3 = _11)) & (_4 = _12)) & (_5 = _13)) & (_6 = _14)) & (_7 = _15)) & true) | (h1(_15, _14, _13, _12, _11, _10, _9, _8, _7, _6, _5, _4, _3, _2, _1, _0) = 0))
+      // Clause(h1(P15, P14, P13, P12, P11, P10, P9, P8, P7, P6, P5, P4, P3, P2, P1, P0),List(),((((((((P0 = P8) & (P1 = P9)) & (P2 = P10)) & (P3 = P11)) & (P4 = P12)) & (P5 = P13)) & (P6 = P14)) & (P7 = P15)))
+      return toClause((IBinFormula) input);
+    }
+    if (input instanceof IIntFormula) {
+      return toClause(toAtom((IIntFormula) input));
+    }
+
+    throw new IllegalArgumentException("Illegal horn clause: " + input);
+  }
+}

From 813f5d64d88de2db527939b489686a28e86ef106 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Tue, 26 May 2026 20:02:18 +0200
Subject: [PATCH 25/77] various eldarica converter fixes

---
 .../eldarica/PrincessHornConverter.java       | 334 +++++++++++-------
 .../java_smt/test/EldaricaHornProverTest.java |  15 +-
 2 files changed, 216 insertions(+), 133 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
index c3aabf9e07..8293eb5eed 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -10,17 +10,25 @@
 
 package org.sosy_lab.java_smt.solvers.princess.eldarica;
 
+import ap.basetypes.IdealInt;
 import ap.parser.IAtom;
 import ap.parser.IBinFormula;
 import ap.parser.IBinJunctor;
 import ap.parser.IBoolLit;
+import ap.parser.IConstant;
+import ap.parser.IEquation;
 import ap.parser.IFormula;
 import ap.parser.IFunApp;
 import ap.parser.IIntFormula;
+import ap.parser.IIntLit;
 import ap.parser.IIntRelation;
 import ap.parser.INot;
+import ap.parser.IPlus;
 import ap.parser.ISortedQuantified;
+import ap.parser.ISortedVariable;
 import ap.parser.ITerm;
+import ap.parser.ITimes;
+import ap.terfor.ConstantTerm;
 import ap.terfor.conjunctions.Quantifier.ALL$;
 import ap.terfor.preds.Predicate;
 import ap.types.MonoSortedIFunction;
@@ -36,6 +44,8 @@
 
 public class PrincessHornConverter {
   private final ArrayList<Predicate> predicates = new ArrayList<>();
+  private final ArrayList<IConstant> parameters = new ArrayList<>();
+  private int variables = 0;
 
   private Predicate toPredicate(final MonoSortedIFunction function) {
     // Predicate does not implement hashCode nor equals, this deduplicates the objects. Not 100%
@@ -52,186 +62,258 @@ private Predicate toPredicate(final MonoSortedIFunction function) {
     return predicate;
   }
 
-  private List<IFormula> flatten(final IBinFormula input) {
-    if (input.j() == IBinJunctor.And()) {
-      return flattenAnd(input);
-    }
-    if (input.j() == IBinJunctor.Or()) {
-      return flattenOr(input);
+  class ClauseContext {
+    private IFormula constraint = new IBoolLit(true);
+
+
+    private List<IFormula> flatten(final IBinFormula input) {
+      if (input.j() == IBinJunctor.And()) {
+        return flattenAnd(input);
+      }
+
+      throw new IllegalArgumentException("Illegal horn clause: " + input);
     }
 
-    throw new IllegalArgumentException("Illegal horn clause: " + input);
-  }
+    private List<IFormula> flattenAnd(final IBinFormula input) {
+      final ArrayList<IFormula> atoms = new ArrayList<>();
+      atoms.addAll(flatten(input.f1()));
+      atoms.addAll(flatten(input.f2()));
 
-  private List<IFormula> flattenAnd(final IBinFormula input) {
-    final ArrayList<IFormula> atoms = new ArrayList<>();
-    atoms.addAll(flatten(input.f1()));
-    atoms.addAll(flatten(input.f2()));
+      return atoms;
+    }
 
-    return atoms;
-  }
+    private List<IFormula> flatten(final IFormula input) {
+      if (input instanceof IBinFormula) {
+        return flatten((IBinFormula) input);
+      }
 
-  private List<IFormula> flattenOr(final IBinFormula input) {
-    final ArrayList<IFormula> atoms = new ArrayList<>();
+      return List.of(input);
+    }
 
-    throw new IllegalArgumentException("Illegal horn clause: " + input);
-  }
+    private Clause toClause(final IAtom head, final IAtom rest) {
+      return new Clause(head, CollectionConverters.asScala(List.of(rest)).toList(),
+          this.constraint);
+    }
 
-  private List<IFormula> flatten(final IFormula input) {
-    if (input instanceof IBinFormula) {
-      return flatten((IBinFormula) input);
+    private Clause toClause(final IAtom head, final IIntFormula rest) {
+      var atom = toAtom(rest);
+      if (atom != null) {
+        return new Clause(head, CollectionConverters.asScala(List.of(atom)).toList(),
+            this.constraint);
+      }
+      return new Clause(head, List$.MODULE$.empty(), this.constraint.andSimplify(toFormula(rest)));
     }
 
-    return List.of(input);
-  }
+    private Clause toClause(final IAtom head, final IBinFormula rest) {
+      List<IAtom> body = new ArrayList<>();
+      IFormula constraint = this.constraint;
 
-  private Clause toClause(final IAtom head, final IAtom rest) {
-    return new Clause(head, CollectionConverters.asScala(List.of(rest)).toList(),
-        new IBoolLit(true));
-  }
+      for (IFormula and : flatten(rest)) {
+        if (and instanceof IAtom) {
+          body.add((IAtom) and);
+          continue;
+        }
+        if (and instanceof IIntFormula) {
+          var atom = toAtom((IIntFormula) and);
+          if (atom != null) {
+            body.add(atom);
+            continue;
+          }
+        }
+
+        constraint = constraint.andSimplify(toFormula(and));
+      }
 
-  private Clause toClause(final IAtom head, final IIntFormula rest) {
-    var atom = toAtom(rest);
-    if (atom != null) {
-      return new Clause(head, CollectionConverters.asScala(List.of(atom)).toList(),
-          new IBoolLit(true));
+
+      return new Clause(head, CollectionConverters.asScala(body).toList(), constraint);
     }
-    return new Clause(head, List$.MODULE$.empty(), rest);
-  }
 
-  private Clause toClause(final IAtom head, final IBinFormula rest) {
-    List<IAtom> body = new ArrayList<>();
-    IFormula constraint = null;
+    private Clause toClause(final IAtom head, final IFormula rest, final IFormula constraint) {
+      // INPUT: ((B1 = 0) & C2) ; constraint: C1
+      // CLAUSE: Clause(FALSE, List(B1), (C2 & !C1))
+      var clause = toClause(head, rest);
 
-    for (IFormula and : flatten(rest)) {
-      if (and instanceof IAtom) {
-        body.add((IAtom) and);
-        continue;
+      return new Clause(clause.head(), clause.body(), new IBinFormula(IBinJunctor.And(),
+          clause.constraint(), this.constraint.andSimplify(new INot(constraint))));
+    }
+
+    private Clause toClause(final IAtom head, final IFormula rest) {
+      if (rest instanceof IAtom) {
+        return toClause(head, (IAtom) rest);
       }
-      if (and instanceof IIntFormula) {
-        var atom = toAtom((IIntFormula) and);
-        if (atom != null) {
-          body.add(atom);
-          continue;
-        }
+      if (rest instanceof IIntFormula) {
+        return toClause(head, (IIntFormula) rest);
       }
 
-      if (constraint == null) {
-        constraint = and;
-      } else {
-        constraint = new IBinFormula(IBinJunctor.And(), constraint, and);
+      if (rest instanceof IBinFormula) {
+        return toClause(head, (IBinFormula) rest);
       }
-    }
 
+      throw new RuntimeException("TODO");
+    }
 
-    var _constraint = constraint == null ? new IBoolLit(true) : constraint;
+    private IConstant addConstraint(final ITerm term) {
+      var variable = new IConstant(new ConstantTerm("T" + ++variables));
+      var constraint = new IEquation(variable, term);
 
-    return new Clause(head, CollectionConverters.asScala(body).toList(), _constraint);
-  }
+      this.constraint = this.constraint.andSimplify(constraint);
 
-  private Clause toClause(final IAtom head, final IFormula rest, final IFormula constraint) {
-    // INPUT: ((B1 = 0) & C2) ; constraint: C1
-    // CLAUSE: Clause(FALSE, List(B1), (C2 & !C1))
-    var clause = toClause(head, rest);
+      return variable;
+    }
 
-    return new Clause(clause.head(), clause.body(), new IBinFormula(IBinJunctor.And(),
-        clause.constraint(), new INot(constraint)));
-  }
+    private IFormula toFormula(final IFormula formula) {
+      if (formula instanceof IIntFormula i) {
+        return new IIntFormula(i.rel(), toTerm(i.t()));
+      }
+      if (formula instanceof IEquation equation) {
+        return new IEquation(toTerm(equation.left()), toTerm(equation.right()));
+      }
 
-  private Clause toClause(final IAtom head, final IFormula rest) {
-    if (rest instanceof IAtom) {
-      return toClause(head, (IAtom) rest);
+      return formula;
     }
-    if (rest instanceof IIntFormula) {
-      return toClause(head, (IIntFormula) rest);
+
+    private IConstant toVariable(final ISortedVariable variable) {
+      var name = "V" + variable.index();
+
+      for(IConstant constant : parameters) {
+        if(constant.c().name().equals(name)) {
+          return constant;
+        }
+      }
+
+      var constant = new IConstant(new ConstantTerm(name));
+      parameters.add(constant);
+      return constant;
     }
 
-    if (rest instanceof IBinFormula) {
-      return toClause(head, (IBinFormula) rest);
+    private ITerm toTerm(final IdealInt term) {
+      return new IIntLit(term);
     }
 
-    throw new RuntimeException("TODO");
-  }
+    private ITerm toTerm(final ITerm term) {
+      if (term instanceof IIntLit lit) {
+        return lit;
+      }
+      if (term instanceof ISortedVariable variable) {
+        return toVariable(variable);
+      }
+      if (term instanceof IPlus plus) {
+        return new IPlus(toTerm(plus.t1()), toTerm(plus.t2()));
+      }
+      if (term instanceof ITimes times) {
+        return new ITimes(times.coeff(), toTerm(times.subterm()));
+      }
+      // TODO: epsilon, ITermITE, function
 
-  @Nullable
-  private IAtom toAtom(final IIntFormula formula) {
-    if (formula.t() instanceof IFunApp t && formula.rel() == IIntRelation.EqZero()) {
-      if (t.fun() instanceof MonoSortedIFunction fun) {
-        return new IAtom(toPredicate(fun), t.args());
+      return term;
+    }
+
+    private ITerm toConstraint(final ITerm term) {
+      if (term instanceof IIntLit lit) {
+        return lit;
+      }
+      if (term instanceof ISortedVariable variable) {
+        return toVariable(variable);
       }
+      return addConstraint(toTerm(term));
     }
 
-    return null;
-  }
+    private Seq<ITerm> toTerm(final Seq<ITerm> terms) {
+      final var output = new ArrayList<ITerm>();
 
-  private Clause toClause(final IAtom input) {
-    return new Clause(input, List$.MODULE$.empty(), new IBoolLit(true));
-  }
+      for (ITerm term : CollectionConverters.asJava(terms)) {
+        output.add(toConstraint(term));
+      }
 
-  private Clause toClause(final ISortedQuantified input) {
-    if (input.quan() != ALL$.MODULE$) {
-      throw new IllegalArgumentException("Illegal horn clause: " + input);
+      return CollectionConverters.asScala(output).toSeq();
     }
 
-    return toClause(input.subformula());
-  }
+    @Nullable
+    private IAtom toAtom(final IIntFormula formula) {
+      if (formula.t() instanceof IFunApp t && formula.rel() == IIntRelation.EqZero()) {
+        if (t.fun() instanceof MonoSortedIFunction fun) {
+          return new IAtom(toPredicate(fun), toTerm(t.args()));
+        }
+      }
 
-  private Clause toClause(final IBinFormula input) {
-    if (input.j() != IBinJunctor.Or()) {
-      throw new IllegalArgumentException("Illegal horn clause: " + input);
+      return null;
     }
 
-    INot not;
-    IFormula other;
+    private Clause toClause(final IAtom input) {
+      return new Clause(input, List$.MODULE$.empty(), this.constraint);
+    }
 
+    private Clause toClause(final ISortedQuantified input) {
+      if (input.quan() != ALL$.MODULE$) {
+        throw new IllegalArgumentException("Illegal horn clause: " + input);
+      }
 
-    if (input.f1() instanceof INot) {
-      not = (INot) input.f1();
-      other = input.f2();
-    } else if (input.f2() instanceof INot) {
-      not = (INot) input.f2();
-      other = input.f1();
-    } else {
-      throw new RuntimeException("TODO");
+      return toClause(input.subformula()); // TODO: Really?
     }
 
-    IAtom head;
+    private Clause toClause(final IBinFormula input) {
+      if (input.j() != IBinJunctor.Or()) {
+        throw new IllegalArgumentException("Illegal horn clause: " + input);
+      }
 
-    if (other instanceof IAtom) {
-      head = (IAtom) other;
-    } else if (other instanceof IIntFormula) {
-      head = toAtom((IIntFormula) other);
-      if (head == null) {
+      INot not;
+      IFormula other;
+
+
+      if (input.f1() instanceof INot) {
+        not = (INot) input.f1();
+        other = input.f2();
+      } else if (input.f2() instanceof INot) {
+        not = (INot) input.f2();
+        other = input.f1();
+      } else {
         throw new RuntimeException("TODO");
       }
-    } else {
-      head = new IAtom(HornClauses.FALSE(), (Seq<ITerm>) Seq$.MODULE$.empty());
 
-      // TODO: (expected) Clause(FALSE,List(mc(P1, P0)),!(!((101 + -1 * P1) >= 0) | (P0 = 92)))
-      // TODO: (actual  ) Clause(FALSE,List(mc(P1, P0)),(((101 + -1 * P1) >= 0) & !(P0 = 91)))
-      return toClause(head, not.subformula(), other);
+      IAtom head;
+
+      if (other instanceof IAtom) {
+        head = (IAtom) other;
+      } else if (other instanceof IIntFormula) {
+        head = toAtom((IIntFormula) other);
+        if (head == null) {
+          throw new RuntimeException("TODO");
+        }
+      } else {
+        head = new IAtom(HornClauses.FALSE(), (Seq<ITerm>) Seq$.MODULE$.empty());
+
+        // TODO: (expected) Clause(FALSE,List(mc(P1, P0)),!(!((101 + -1 * P1) >= 0) | (P0 = 92)))
+        // TODO: (actual  ) Clause(FALSE,List(mc(P1, P0)),(((101 + -1 * P1) >= 0) & !(P0 = 91)))
+        return toClause(head, not.subformula(), toFormula(other));
+      }
+
+
+      return toClause(head, not.subformula());
     }
 
+    public Clause toClause(IFormula input) {
+      if (input instanceof ISortedQuantified) {
+        return toClause((ISortedQuantified) input);
+      }
+      if (input instanceof IAtom) {
+        return toClause((IAtom) input);
+      }
+      if (input instanceof IBinFormula) {
+        // (!(((((((((_0 = _8) & (_1 = _9)) & (_2 = _10)) & (_3 = _11)) & (_4 = _12)) & (_5 = _13)) & (_6 = _14)) & (_7 = _15)) & true) | (h1(_15, _14, _13, _12, _11, _10, _9, _8, _7, _6, _5, _4, _3, _2, _1, _0) = 0))
+        // Clause(h1(P15, P14, P13, P12, P11, P10, P9, P8, P7, P6, P5, P4, P3, P2, P1, P0),List(),((((((((P0 = P8) & (P1 = P9)) & (P2 = P10)) & (P3 = P11)) & (P4 = P12)) & (P5 = P13)) & (P6 = P14)) & (P7 = P15)))
+        return toClause((IBinFormula) input);
+      }
+      if (input instanceof IIntFormula) {
+        return toClause(toAtom((IIntFormula) input));
+      }
 
-    return toClause(head, not.subformula());
+      throw new IllegalArgumentException("Illegal horn clause: " + input);
+    }
   }
 
   public Clause toClause(IFormula input) {
-    if (input instanceof ISortedQuantified) {
-      return toClause((ISortedQuantified) input);
-    }
-    if (input instanceof IAtom) {
-      return toClause((IAtom) input);
-    }
-    if (input instanceof IBinFormula) {
-      // (!(((((((((_0 = _8) & (_1 = _9)) & (_2 = _10)) & (_3 = _11)) & (_4 = _12)) & (_5 = _13)) & (_6 = _14)) & (_7 = _15)) & true) | (h1(_15, _14, _13, _12, _11, _10, _9, _8, _7, _6, _5, _4, _3, _2, _1, _0) = 0))
-      // Clause(h1(P15, P14, P13, P12, P11, P10, P9, P8, P7, P6, P5, P4, P3, P2, P1, P0),List(),((((((((P0 = P8) & (P1 = P9)) & (P2 = P10)) & (P3 = P11)) & (P4 = P12)) & (P5 = P13)) & (P6 = P14)) & (P7 = P15)))
-      return toClause((IBinFormula) input);
-    }
-    if (input instanceof IIntFormula) {
-      return toClause(toAtom((IIntFormula) input));
-    }
+    var context = new ClauseContext();
 
-    throw new IllegalArgumentException("Illegal horn clause: " + input);
+    return context.toClause(input);
   }
 }
diff --git a/src/org/sosy_lab/java_smt/test/EldaricaHornProverTest.java b/src/org/sosy_lab/java_smt/test/EldaricaHornProverTest.java
index e3382fd634..94872b4b9e 100644
--- a/src/org/sosy_lab/java_smt/test/EldaricaHornProverTest.java
+++ b/src/org/sosy_lab/java_smt/test/EldaricaHornProverTest.java
@@ -33,6 +33,7 @@
 import java.util.Arrays;
 import org.junit.Test;
 import org.sosy_lab.java_smt.solvers.princess.EldaricaHornProver;
+import org.sosy_lab.java_smt.solvers.princess.eldarica.PrincessHornConverter;
 import scala.collection.immutable.Seq;
 import scala.collection.immutable.Seq$;
 import scala.collection.immutable.Set;
@@ -60,7 +61,7 @@ public void headWithoutBody() {
     IFormula input = a;
 
 
-    var clause = EldaricaHornProver.toClause(input);
+    var clause = new PrincessHornConverter().toClause(input);
 
     assertThat(clause.head()).isEqualTo(a);
     assertThat(clause.body().toSet()).isEqualTo(set());
@@ -77,7 +78,7 @@ public void multipleBodyAtomsAndHead() {
         new IBinFormula(IBinJunctor.And(), b, c), d)), a);
 
 
-    var clause = EldaricaHornProver.toClause(input);
+    var clause = new PrincessHornConverter().toClause(input);
 
     assertThat(clause.head()).isEqualTo(a);
     assertThat(clause.body().toSet()).isEqualTo(set(b, c, d));
@@ -92,7 +93,7 @@ public void singleBodyWithHead() {
     IFormula input = new IBinFormula(IBinJunctor.Or(), new INot(b), a);
 
 
-    var clause = EldaricaHornProver.toClause(input);
+    var clause = new PrincessHornConverter().toClause(input);
 
     assertThat(clause.head()).isEqualTo(a);
     assertThat(clause.body().toSet()).isEqualTo(set(b));
@@ -107,7 +108,7 @@ public void predicateHead() {
     IFormula f0 = new IIntFormula(IIntRelation.EqZero(), f);
 
 
-    var clause = EldaricaHornProver.toClause(f0);
+    var clause = new PrincessHornConverter().toClause(f0);
 
     assertThat(clause.head().toString()).isEqualTo(new IAtom(new Predicate("f", 1), args).toString());
     assertThat(clause.body().toSet()).isEqualTo(set());
@@ -127,7 +128,7 @@ public void predicateHeadWithBody() {
     IFormula input = new IBinFormula(IBinJunctor.Or(), new INot(h0), f0);
 
 
-    var clause = EldaricaHornProver.toClause(input);
+    var clause = new PrincessHornConverter().toClause(input);
 
     assertThat(clause.head().toString()).isEqualTo(new IAtom(new Predicate("f", 1), args).toString());
     assertThat(clause.body().toSet().toString()).isEqualTo(set(new IAtom(new Predicate("h", 1),
@@ -151,7 +152,7 @@ public void constraintWithHeadAndBody() {
         constraint, body)), a);
 
 
-    var clause = EldaricaHornProver.toClause(input);
+    var clause = new PrincessHornConverter().toClause(input);
 
     assertThat(clause.head()).isEqualTo(a);
     assertThat(clause.body().toSet()).isEqualTo(set(b, c));
@@ -170,7 +171,7 @@ public void constraintWithHead() {
     IFormula input = new IBinFormula(IBinJunctor.Or(), new INot(constraint), a);
 
 
-    var clause = EldaricaHornProver.toClause(input);
+    var clause = new PrincessHornConverter().toClause(input);
 
     assertThat(clause.head()).isEqualTo(a);
     assertThat(clause.body().toSet()).isEqualTo(set());

From bcba11a36be1b306adb10e0de83b8823e3dc2f8f Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Tue, 26 May 2026 20:04:21 +0200
Subject: [PATCH 26/77] horn sample test

Taken from CHC comp and the other one is a refactored one from one example page for CHC horn clauses, don't remember the actual source anymore :(
---
 .../solvers/princess/EldaricaHornProver.java  |  39 +-
 .../java_smt/test/horn/02.c_000.license       |   1 +
 .../sosy_lab/java_smt/test/horn/02.c_000.smt2 | 364 ++++++++++++++++++
 .../java_smt/test/horn/HornExampleTest.java   | 206 ++++++++++
 .../java_smt/test/horn/small_sat.smt2         |  11 +
 .../java_smt/test/horn/small_unsat.smt2       |  11 +
 6 files changed, 618 insertions(+), 14 deletions(-)
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/02.c_000.license
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/02.c_000.smt2
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/small_sat.smt2
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/small_unsat.smt2

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
index 11d054a0e1..6547988937 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
@@ -10,28 +10,21 @@
 
 package org.sosy_lab.java_smt.solvers.princess;
 
+import ap.CmdlMain.NullStream$;
 import ap.api.SimpleAPI;
 import ap.parser.IAtom;
-import ap.parser.IBinFormula;
-import ap.parser.IBinJunctor;
-import ap.parser.IBoolLit;
 import ap.parser.IFormula;
-import ap.parser.IFunApp;
-import ap.parser.IIntFormula;
-import ap.parser.IIntRelation;
-import ap.parser.INot;
-import ap.parser.ISortedQuantified;
-import ap.parser.ITerm;
-import ap.terfor.conjunctions.Quantifier.ALL$;
 import ap.terfor.preds.Predicate;
-import ap.types.MonoSortedIFunction;
 import com.google.common.base.Preconditions;
 import java.util.ArrayList;
-import java.util.List;
 import java.util.Set;
+import lazabs.horn.CEGARHornWrapper;
 import lazabs.horn.HornAPI;
-import lazabs.horn.bottomup.HornClauses;
+import lazabs.horn.HornWrapper;
+import lazabs.horn.Util.Dag;
+import lazabs.horn.abstractions.EmptyVerificationHints$;
 import lazabs.horn.bottomup.HornClauses.Clause;
+import lazabs.horn.preprocessor.DefaultPreprocessor;
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.sosy_lab.common.ShutdownNotifier;
 import org.sosy_lab.java_smt.api.BooleanFormula;
@@ -39,7 +32,10 @@
 import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
 import org.sosy_lab.java_smt.api.SolverException;
 import org.sosy_lab.java_smt.solvers.princess.eldarica.PrincessHornConverter;
+import scala.Function0;
+import scala.collection.immutable.Map;
 import scala.jdk.javaapi.CollectionConverters;
+import scala.util.Either;
 
 public class EldaricaHornProver extends PrincessAbstractProver<Void> implements
                                                                      HornProverEnvironment {
@@ -93,9 +89,24 @@ protected Void addConstraintImpl(BooleanFormula constraint) throws InterruptedEx
     return null;
   }
 
+  private Either<Function0<Map<Predicate, IFormula>>, Function0<Dag<IAtom>>> solve() {
+    var clauses = CollectionConverters.asScala(this.clauses).toSeq();
+    var preprocessor = new DefaultPreprocessor();
+    var preprocessed = preprocessor.process(clauses,EmptyVerificationHints$.MODULE$);
+
+    var result = new CEGARHornWrapper(clauses, preprocessed._1(), preprocessed._2(),
+        preprocessed._3(), false, System.err).result();
+
+
+    return result;
+  }
+
   @Override
   protected boolean isUnsatImpl() throws SolverException {
-    return !this.horn.isSat(CollectionConverters.asScala(this.clauses));
+    var result = solve();
+
+    return result.isRight();
+   // return !this.horn.isSat(CollectionConverters.asScala(this.clauses));
   }
 
   // TODO: Model, push/pop?.
diff --git a/src/org/sosy_lab/java_smt/test/horn/02.c_000.license b/src/org/sosy_lab/java_smt/test/horn/02.c_000.license
new file mode 100644
index 0000000000..1abba28dd5
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/02.c_000.license
@@ -0,0 +1 @@
+SPDX-License-Identifier: Apache-2.0
diff --git a/src/org/sosy_lab/java_smt/test/horn/02.c_000.smt2 b/src/org/sosy_lab/java_smt/test/horn/02.c_000.smt2
new file mode 100644
index 0000000000..1d3baa6d89
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/02.c_000.smt2
@@ -0,0 +1,364 @@
+(set-logic HORN)
+
+
+(declare-fun |h10| ( Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h21| ( Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h22| ( Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h15| ( Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h23| ( Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h20| ( Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h8| ( Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h16| ( Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h4| ( Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h11| ( Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h13| ( Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |CHC_COMP_FALSE| ( ) Bool)
+(declare-fun |h3| ( Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h17| ( Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h6| ( Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h1| ( Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h14| ( Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h12| ( Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h5| ( Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h7| ( Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h19| ( Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h18| ( Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h9| ( Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h2| ( Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int Int ) Bool)
+
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (v_8 Int) (v_9 Int) (v_10 Int) (v_11 Int) (v_12 Int) (v_13 Int) (v_14 Int) (v_15 Int) )
+    (=>
+      (and
+        (and true
+     (= v_8 A)
+     (= v_9 B)
+     (= v_10 C)
+     (= v_11 D)
+     (= v_12 E)
+     (= v_13 F)
+     (= v_14 G)
+     (= v_15 H))
+      )
+      (h1 A B C D E F G H v_8 v_9 v_10 v_11 v_12 v_13 v_14 v_15)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) (Q Int) (R Int) (S Int) (T Int) (U Int) (V Int) )
+    (=>
+      (and
+        (h1 A B C D E F G H Q R S T U V O P)
+        (and (= M 0) (= L 0) (= K 1) (= J 0) (= I 1) (= N 0))
+      )
+      (h2 A B C D E F G H I J K L M N O P)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) )
+    (=>
+      (and
+        (h2 A B C D E F G H I J K L M N O P)
+        true
+      )
+      (h3 A B C D E F G H I J K L M N O P)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) )
+    (=>
+      (and
+        (h3 A B C D E F G H I J K L M N O P)
+        true
+      )
+      (h4 A B C D E F G H I J K L M N O P)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) )
+    (=>
+      (and
+        (h4 A B C D E F G H I J K L M N O P)
+        true
+      )
+      (h5 A B C D E F G H I J K L M N O P)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) )
+    (=>
+      (and
+        (h19 A B C D E F G H I J K L M N O P)
+        true
+      )
+      (h5 A B C D E F G H I J K L M N O P)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) )
+    (=>
+      (and
+        (h5 A B C D E F G H I J K L M N O P)
+        true
+      )
+      (h6 A B C D E F G H I J K L M N O P)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) )
+    (=>
+      (and
+        (h6 A B C D E F G H I J K L M N O P)
+        true
+      )
+      (h7 A B C D E F G H I J K L M N O P)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) )
+    (=>
+      (and
+        (h7 A B C D E F G H I J K L M N O P)
+        true
+      )
+      (h8 A B C D E F G H I J K L M N O P)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) )
+    (=>
+      (and
+        (h8 A B C D E F G H I J K L M N O P)
+        (<= O (- 1))
+      )
+      (h9 A B C D E F G H I J K L M N O P)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) (Q Int) (R Int) )
+    (=>
+      (and
+        (h9 A B C D E F G H I J Q L R N O P)
+        (and (= Q (+ 1 (* (- 1) L) (* (- 1) N) K (* (- 1) M))) (= R (+ (- 1) M)))
+      )
+      (h10 A B C D E F G H I J K L M N O P)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) (Q Int) (R Int) )
+    (=>
+      (and
+        (h11 A B C D E F G H I J Q L R N O P)
+        (and (= Q (+ 1 (* (- 1) L) (* (- 1) N) K (* (- 1) M))) (= R (+ (- 1) M)))
+      )
+      (h10 A B C D E F G H I J K L M N O P)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) )
+    (=>
+      (and
+        (h8 A B C D E F G H I J K L M N O P)
+        (>= O 1)
+      )
+      (h11 A B C D E F G H I J K L M N O P)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) )
+    (=>
+      (and
+        (h8 A B C D E F G H I J K L M N O P)
+        (= O 0)
+      )
+      (h12 A B C D E F G H I J K L M N O P)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) )
+    (=>
+      (and
+        (h12 A B C D E F G H I J K L M N O P)
+        true
+      )
+      (h13 A B C D E F G H I J K L M N O P)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) )
+    (=>
+      (and
+        (h13 A B C D E F G H I J K L M N O P)
+        true
+      )
+      (h14 A B C D E F G H I J K L M N O P)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) )
+    (=>
+      (and
+        (h10 A B C D E F G H I J K L M N O P)
+        true
+      )
+      (h15 A B C D E F G H I J K L M N O P)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) )
+    (=>
+      (and
+        (h15 A B C D E F G H I J K L M N O P)
+        true
+      )
+      (h16 A B C D E F G H I J K L M N O P)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) (Q Int) )
+    (=>
+      (and
+        (h16 A B C D E F G H I J K Q M N O P)
+        (= Q (+ (- 1) L))
+      )
+      (h17 A B C D E F G H I J K L M N O P)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) )
+    (=>
+      (and
+        (h15 A B C D E F G H I J K L M N O P)
+        true
+      )
+      (h18 A B C D E F G H I J K L M N O P)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) (Q Int) )
+    (=>
+      (and
+        (h18 A B C D E F G H I J K L M Q O P)
+        (= Q (+ (- 2) N))
+      )
+      (h19 A B C D E F G H I J K L M N O P)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) (Q Int) )
+    (=>
+      (and
+        (h20 A B C D E F G H I J K L M Q O P)
+        (= Q (+ (- 2) N))
+      )
+      (h19 A B C D E F G H I J K L M N O P)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) (Q Int) )
+    (=>
+      (and
+        (h17 A B C D E F G H I J K L M Q O P)
+        (= Q (+ (- 2) N))
+      )
+      (h19 A B C D E F G H I J K L M N O P)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) )
+    (=>
+      (and
+        (h15 A B C D E F G H I J K L M N O P)
+        true
+      )
+      (h20 A B C D E F G H I J K L M N O P)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) )
+    (=>
+      (and
+        (h14 A B C D E F G H I J K L M N O P)
+        true
+      )
+      (h21 A B C D E F G H I J K L M N O P)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) )
+    (=>
+      (and
+        (h21 A B C D E F G H I J K L M N O P)
+        (<= (+ L (* (- 1) M)) (- 1))
+      )
+      (h22 A B C D E F G H I J K L M N O P)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) )
+    (=>
+      (and
+        (h21 A B C D E F G H I J K L M N O P)
+        (>= (+ L (* (- 1) M)) 1)
+      )
+      (h23 A B C D E F G H I J K L M N O P)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) )
+    (=>
+      (and
+        (h22 A B C D E F G H I J K L M N O P)
+        true
+      )
+      CHC_COMP_FALSE
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) )
+    (=>
+      (and
+        (h23 A B C D E F G H I J K L M N O P)
+        true
+      )
+      CHC_COMP_FALSE
+    )
+  )
+)
+(assert
+  (forall ( (CHC_COMP_UNUSED Bool) )
+    (=>
+      (and
+        CHC_COMP_FALSE
+      )
+      false
+    )
+  )
+)
diff --git a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
new file mode 100644
index 0000000000..1fd269e070
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
@@ -0,0 +1,206 @@
+/*
+ * This file is part of JavaSMT,
+ * an API wrapper for a collection of SMT solvers:
+ * https://github.com/sosy-lab/java-smt
+ *
+ * SPDX-FileCopyrightText: 2026 Dirk Beyer <https://www.sosy-lab.org>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.sosy_lab.java_smt.test.horn;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.HashMap;
+import lazabs.GlobalParameters;
+import org.junit.Test;
+import org.sosy_lab.java_smt.SolverContextFactory;
+import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
+import org.sosy_lab.java_smt.api.FormulaType;
+import org.sosy_lab.java_smt.api.HornProverEnvironment;
+import org.sosy_lab.java_smt.test.Yes;
+import scala.collection.immutable.List;
+import scala.collection.immutable.Map;
+import scala.jdk.javaapi.CollectionConverters;
+
+public class HornExampleTest {
+  public void booleanJavaSMT() throws Exception {
+    final var context = SolverContextFactory.createSolverContext(Solvers.PRINCESS);
+
+    var formulas = context.getFormulaManager();
+
+    var varA = formulas.getIntegerFormulaManager().makeVariable("a");
+    var varB = formulas.getIntegerFormulaManager().makeVariable("b");
+    var varC = formulas.getIntegerFormulaManager().makeNumber(5);
+
+    var formular1 = formulas.getIntegerFormulaManager().equal(varA, varB);
+    var formular2 = formulas.getIntegerFormulaManager().greaterOrEquals(varA, varC);
+
+    var formular = formulas.getBooleanFormulaManager().and(formular1, formular2);
+
+    var prover = context.newProverEnvironment();
+
+    prover.addConstraint(formular);
+
+    assertFalse(prover.isUnsat());
+  }
+
+  @Test
+  public void hornJavaSMT() throws Exception {
+    final var context = SolverContextFactory.createSolverContext(Solvers.ELDARICA);
+
+    var intf = context.getFormulaManager().getIntegerFormulaManager();
+    var horn = context.getFormulaManager().getBooleanFormulaManager();
+
+    var varA = horn.makeVariable("a");
+    var varB = horn.makeVariable("b");
+    var varC = horn.makeVariable("c");
+    var varD = horn.makeVariable("d");
+
+    var varE = intf.makeVariable("e");
+    var n1 = intf.makeNumber(1);
+
+
+    var clause1 = horn.makeHornClause(varA, jList(varB, varC), intf.greaterOrEquals(varE, n1));
+    var clause11 = horn.makeHornClause(varA, jList(), intf.greaterThan(varE, n1));
+    var clause2 = horn.makeHornClause(jList(varB)); // TODO: Simplify to true???
+    var clause3 = horn.makeHornClause(varA, jList(varC));
+    {
+
+      var prover = context.newProverEnvironment();
+
+      prover.addConstraint(clause1);
+      prover.addConstraint(clause2);
+      prover.addConstraint(clause3);
+
+      assertFalse(prover.isUnsat());
+    }
+    {
+
+      var prover = context.newHornProverEnvironment();
+
+      prover.addConstraint(clause1);
+      prover.addConstraint(clause2);
+      prover.addConstraint(clause3);
+
+      assertFalse(prover.isUnsat());
+    }
+  }
+
+  @Test
+  public void hornJavaSMTPredicate() throws Exception {
+    final var context = SolverContextFactory.createSolverContext(Solvers.ELDARICA);
+
+    // Pretty much taken from https://github.com/uuverifiers/eldarica/blob/master/src/test/scala/lazabs/horn/HornAPI.scala#L55
+    var integer = context.getFormulaManager().getIntegerFormulaManager();
+    var horn = context.getFormulaManager().getBooleanFormulaManager();
+    var uf = context.getFormulaManager().getUFManager();
+
+
+    var p0 = uf.declareUF("p0", FormulaType.BooleanType, FormulaType.IntegerType);
+    var p1 = uf.declareUF("p1", FormulaType.BooleanType, FormulaType.IntegerType);
+    var p2 = uf.declareUF("p2", FormulaType.BooleanType, FormulaType.IntegerType);
+
+    var n0 = integer.makeNumber(0);
+    var n1 = integer.makeNumber(1);
+    var n2 = integer.makeNumber(2);
+
+    var x = integer.makeVariable("x");
+
+    var p0X = uf.callUF(p0, jList(x));
+    var p0X_1 = uf.callUF(p0, jList(integer.subtract(x, n1)));
+    var p1X = uf.callUF(p1, jList(x));
+    var p2X = uf.callUF(p2, jList(x));
+
+
+    var clause1 = horn.makeHornClause(p0X, jList(), integer.greaterThan(x, n2));
+    var clause2 = horn.makeHornClause(p1X, jList(p0X), integer.greaterThan(x, n0));
+    var clause3 = horn.makeHornClause(p0X_1, jList(p1X));
+    var clause4 = horn.makeHornClause(p2X, jList(p0X), integer.lessOrEquals(x, n0));
+    var clause5 = horn.makeHornClause(jList(p2X), integer.greaterOrEquals(x, n0));
+    {
+      var prover = context.newProverEnvironment();
+
+      prover.addConstraint(clause1);
+      prover.addConstraint(clause2);
+      prover.addConstraint(clause3);
+      prover.addConstraint(clause4);
+      prover.addConstraint(clause5);
+
+      assertFalse(prover.isUnsat());
+    }
+    {
+      var prover = context.newHornProverEnvironment();
+
+      prover.addConstraint(clause1);
+      prover.addConstraint(clause2);
+      prover.addConstraint(clause3);
+      prover.addConstraint(clause4);
+      prover.addConstraint(clause5);
+
+      assertFalse(prover.isUnsat());
+    }
+  }
+
+  private HornProverEnvironment solveSmtLib2(final String file) throws Exception {
+    var input =
+        new String(Yes.class.getResourceAsStream("/org/sosy_lab/java_smt/test/horn/" + file +
+            ".smt2").readAllBytes());
+
+    final var context = SolverContextFactory.createSolverContext(Solvers.ELDARICA);
+
+    var formula = context.getFormulaManager();
+    var constraints = formula.parseAll(input);
+
+    var prover = context.newHornProverEnvironment();
+
+    for (var constraint : constraints) {
+      prover.addConstraint(constraint);
+    }
+
+    return prover;
+  }
+
+
+  @Test
+  public void smtlib2() throws Exception {
+    var prover = solveSmtLib2("02.c_000");
+
+    assertFalse(prover.isUnsat());
+  }
+
+  @Test
+  public void smtlib2SmallUnsat() throws Exception {
+    GlobalParameters.get().setLogLevel(3);
+    /*
+    mc(A,B) :- ((A + -100) >= 1),(B = (A + -10)).
+    mc(A,B) :- (A =< 100),mc(C,B),(D = (A + 11)),mc(D,C).
+    false :- \+((A = 91)),(B =< 101),mc(B,A).
+     */
+
+    var prover = solveSmtLib2("small_unsat");
+
+    assertTrue(prover.isUnsat());
+  }
+
+
+  @Test
+  public void smtlib2SmallSat() throws Exception {
+    /*
+    mc(A,B) :- ((A + -100) >= 1),(B = (A + -10)).
+    mc(A,B) :- (A =< 100),mc(C,B),(D = (A + 11)),mc(D,C).
+    false :- \+((A = 91)),(B =< 101),mc(B,A).
+     */
+
+    var prover = solveSmtLib2("small_sat");
+
+    assertFalse(prover.isUnsat());
+  }
+
+
+  private  <A> java.util.List<A> jList(A... vars) {
+    return java.util.Arrays.asList(vars);
+  }
+}
diff --git a/src/org/sosy_lab/java_smt/test/horn/small_sat.smt2 b/src/org/sosy_lab/java_smt/test/horn/small_sat.smt2
new file mode 100644
index 0000000000..c61dcf7d9e
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/small_sat.smt2
@@ -0,0 +1,11 @@
+(set-logic HORN)
+(declare-fun fun (Int Int) Bool)
+
+(assert (forall ((m Int))
+          (=> (> m 100) (fun m (- m 10)))))
+
+(assert (forall ((m Int) (n Int) (p Int))
+           (=> (and (<= m 100) (fun (+ m 11) p) (fun p n)) (fun m n))))
+
+(assert (forall ((m Int) (n Int))
+            (=> (and (fun m n) (<= m 101)) (= n 91))))
diff --git a/src/org/sosy_lab/java_smt/test/horn/small_unsat.smt2 b/src/org/sosy_lab/java_smt/test/horn/small_unsat.smt2
new file mode 100644
index 0000000000..16b1a9dcf0
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/small_unsat.smt2
@@ -0,0 +1,11 @@
+(set-logic HORN)
+(declare-fun fun (Int Int) Bool)
+
+(assert (forall ((m Int))
+          (=> (> m 100) (fun m (- m 10)))))
+
+(assert (forall ((m Int) (n Int) (p Int))
+           (=> (and (<= m 100) (fun (+ m 11) p) (fun p n)) (fun m n))))
+
+(assert (forall ((m Int) (n Int))
+            (=> (and (fun m n) (<= m 101)) (= n 92))))

From 3d1c0b57249ed810d280c149e76a5b9845252d0c Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Sun, 31 May 2026 16:11:41 +0200
Subject: [PATCH 27/77] more smt tests

Somehow they still fail...
---
 .../java_smt/test/horn/01.c-bv_000.license    |   1 +
 .../java_smt/test/horn/01.c-bv_000.smt2       | 231 ++++++
 .../java_smt/test/horn/HornExampleTest.java   |  26 +-
 .../ch-triangle-location-nr.2-bv_000.license  |   1 +
 .../ch-triangle-location-nr.2-bv_000.smt2     | 754 ++++++++++++++++++
 5 files changed, 1005 insertions(+), 8 deletions(-)
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/01.c-bv_000.license
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/01.c-bv_000.smt2
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/ch-triangle-location-nr.2-bv_000.license
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/ch-triangle-location-nr.2-bv_000.smt2

diff --git a/src/org/sosy_lab/java_smt/test/horn/01.c-bv_000.license b/src/org/sosy_lab/java_smt/test/horn/01.c-bv_000.license
new file mode 100644
index 0000000000..1abba28dd5
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/01.c-bv_000.license
@@ -0,0 +1 @@
+SPDX-License-Identifier: Apache-2.0
diff --git a/src/org/sosy_lab/java_smt/test/horn/01.c-bv_000.smt2 b/src/org/sosy_lab/java_smt/test/horn/01.c-bv_000.smt2
new file mode 100644
index 0000000000..b859dad539
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/01.c-bv_000.smt2
@@ -0,0 +1,231 @@
+(set-logic HORN)
+
+
+(declare-fun |h8| ( (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) ) Bool)
+(declare-fun |h4| ( (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) ) Bool)
+(declare-fun |h13| ( (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) ) Bool)
+(declare-fun |h10| ( (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) ) Bool)
+(declare-fun |h7| ( (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) ) Bool)
+(declare-fun |h11| ( (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) ) Bool)
+(declare-fun |h5| ( (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) ) Bool)
+(declare-fun |h2| ( (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) ) Bool)
+(declare-fun |h9| ( (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) ) Bool)
+(declare-fun |h3| ( (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) ) Bool)
+(declare-fun |h12| ( (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) ) Bool)
+(declare-fun |h14| ( (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) ) Bool)
+(declare-fun |h15| ( (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) ) Bool)
+(declare-fun |h16| ( (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) ) Bool)
+(declare-fun |h1| ( (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) ) Bool)
+(declare-fun |h6| ( (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) ) Bool)
+
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (v_5 (_ BitVec 32)) (v_6 (_ BitVec 32)) (v_7 (_ BitVec 32)) (v_8 (_ BitVec 32)) (v_9 (_ BitVec 32)) ) 
+    (=>
+      (and
+        (and true (= v_5 A) (= v_6 B) (= v_7 C) (= v_8 D) (= v_9 E))
+      )
+      (h1 A B C D E v_5 v_6 v_7 v_8 v_9)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) ) 
+    (=>
+      (and
+        (h1 A B C D E K L H I J)
+        (and (= F #x00000001) (= G #x00000001))
+      )
+      (h2 A B C D E F G H I J)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) ) 
+    (=>
+      (and
+        (h2 A B C D E F G H I J)
+        true
+      )
+      (h3 A B C D E F G H I J)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) ) 
+    (=>
+      (and
+        (h3 A B C D E F G H I J)
+        true
+      )
+      (h4 A B C D E F G H I J)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) ) 
+    (=>
+      (and
+        (h4 A B C D E F G H I J)
+        true
+      )
+      (h5 A B C D E F G H I J)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) ) 
+    (=>
+      (and
+        (h10 A B C D E F G H I J)
+        true
+      )
+      (h5 A B C D E F G H I J)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) ) 
+    (=>
+      (and
+        (h5 A B C D E F G H I J)
+        true
+      )
+      (h6 A B C D E F G H I J)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) ) 
+    (=>
+      (and
+        (h6 A B C D E F G H I J)
+        true
+      )
+      (h7 A B C D E F G H I J)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) ) 
+    (=>
+      (and
+        (h7 A B C D E F G H I J)
+        true
+      )
+      (h8 A B C D E F G H I J)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) ) 
+    (=>
+      (and
+        (h8 A B C D E F G H I J)
+        (bvsle J #xffffffff)
+      )
+      (h9 A B C D E F G H I J)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (M (_ BitVec 32)) (N (_ BitVec 32)) ) 
+    (=>
+      (and
+        (h9 A B C D E K L M N J)
+        (and (= F (bvadd H I)) (= L I) (= K H) (= G (bvadd H I)))
+      )
+      (h10 A B C D E F G H I J)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (M (_ BitVec 32)) (N (_ BitVec 32)) ) 
+    (=>
+      (and
+        (h11 A B C D E K L M N J)
+        (and (= F (bvadd H I)) (= L I) (= K H) (= G (bvadd H I)))
+      )
+      (h10 A B C D E F G H I J)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) ) 
+    (=>
+      (and
+        (h8 A B C D E F G H I J)
+        (bvsle #x00000001 J)
+      )
+      (h11 A B C D E F G H I J)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) ) 
+    (=>
+      (and
+        (h8 A B C D E F G H I J)
+        (= J #x00000000)
+      )
+      (h12 A B C D E F G H I J)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) ) 
+    (=>
+      (and
+        (h12 A B C D E F G H I J)
+        true
+      )
+      (h13 A B C D E F G H I J)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) ) 
+    (=>
+      (and
+        (h13 A B C D E F G H I J)
+        true
+      )
+      (h14 A B C D E F G H I J)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) ) 
+    (=>
+      (and
+        (h14 A B C D E F G H I J)
+        true
+      )
+      (h15 A B C D E F G H I J)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) ) 
+    (=>
+      (and
+        (h15 A B C D E F G H I J)
+        (bvsle G #x00000000)
+      )
+      (h16 A B C D E F G H I J)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) ) 
+    (=>
+      (and
+        (h16 A B C D E F G H I J)
+        true
+      )
+      false
+    )
+  )
+)
+
+(check-sat)
+(exit)
diff --git a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
index 1fd269e070..8687e67f4d 100644
--- a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
+++ b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
@@ -13,7 +13,6 @@
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
-import java.util.HashMap;
 import lazabs.GlobalParameters;
 import org.junit.Test;
 import org.sosy_lab.java_smt.SolverContextFactory;
@@ -21,9 +20,6 @@
 import org.sosy_lab.java_smt.api.FormulaType;
 import org.sosy_lab.java_smt.api.HornProverEnvironment;
 import org.sosy_lab.java_smt.test.Yes;
-import scala.collection.immutable.List;
-import scala.collection.immutable.Map;
-import scala.jdk.javaapi.CollectionConverters;
 
 public class HornExampleTest {
   public void booleanJavaSMT() throws Exception {
@@ -165,14 +161,28 @@ private HornProverEnvironment solveSmtLib2(final String file) throws Exception {
 
 
   @Test
-  public void smtlib2() throws Exception {
+  public void smt_02_c_000() throws Exception {
     var prover = solveSmtLib2("02.c_000");
 
     assertFalse(prover.isUnsat());
   }
 
   @Test
-  public void smtlib2SmallUnsat() throws Exception {
+  public void smt_01_c_bv_000() throws Exception {
+    var prover = solveSmtLib2("01.c-bv_000");
+
+    assertFalse(prover.isUnsat());
+  }
+
+  @Test
+  public void smt_ch_triangle_location_nr_2_bv_000() throws Exception {
+    var prover = solveSmtLib2("ch-triangle-location-nr.2-bv_000");
+
+    assertTrue(prover.isUnsat());
+  }
+
+  @Test
+  public void smt_small_unsat() throws Exception {
     GlobalParameters.get().setLogLevel(3);
     /*
     mc(A,B) :- ((A + -100) >= 1),(B = (A + -10)).
@@ -187,7 +197,7 @@ public void smtlib2SmallUnsat() throws Exception {
 
 
   @Test
-  public void smtlib2SmallSat() throws Exception {
+  public void smt_small_sat() throws Exception {
     /*
     mc(A,B) :- ((A + -100) >= 1),(B = (A + -10)).
     mc(A,B) :- (A =< 100),mc(C,B),(D = (A + 11)),mc(D,C).
@@ -200,7 +210,7 @@ public void smtlib2SmallSat() throws Exception {
   }
 
 
-  private  <A> java.util.List<A> jList(A... vars) {
+  private <A> java.util.List<A> jList(A... vars) {
     return java.util.Arrays.asList(vars);
   }
 }
diff --git a/src/org/sosy_lab/java_smt/test/horn/ch-triangle-location-nr.2-bv_000.license b/src/org/sosy_lab/java_smt/test/horn/ch-triangle-location-nr.2-bv_000.license
new file mode 100644
index 0000000000..1abba28dd5
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/ch-triangle-location-nr.2-bv_000.license
@@ -0,0 +1 @@
+SPDX-License-Identifier: Apache-2.0
diff --git a/src/org/sosy_lab/java_smt/test/horn/ch-triangle-location-nr.2-bv_000.smt2 b/src/org/sosy_lab/java_smt/test/horn/ch-triangle-location-nr.2-bv_000.smt2
new file mode 100644
index 0000000000..4f45c147c7
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/ch-triangle-location-nr.2-bv_000.smt2
@@ -0,0 +1,754 @@
+(set-logic HORN)
+
+
+(declare-fun |combined_lturn__bar| ( (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) ) Bool)
+(declare-fun |step_lturn| ( (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) ) Bool)
+(declare-fun |lturn| ( (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) ) Bool)
+(declare-fun |step_lturn__bar| ( (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) ) Bool)
+(declare-fun |CHC_COMP_FALSE| ( ) Bool)
+(declare-fun |combined_lturn| ( (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) (_ BitVec 32) ) Bool)
+
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) )
+    (=>
+      (and
+        (and (bvsle #x00000000 (bvadd #xfffffffd (bvmul #xffffffff F) B))
+     (bvsle #x00000000 (bvadd #xfffffffe (bvmul #xffffffff F) I))
+     (bvsle #x00000000 (bvadd #xfffffffe (bvmul #xffffffff F) A))
+     (bvsle #x00000000 (bvadd #xfffffffe (bvmul #xffffffff L) B))
+     (bvsle #x00000000 (bvadd #xfffffffe G (bvmul #xffffffff L)))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff J) I))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff F) J))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff F) L))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff A) B))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff L) A))
+     (bvsle #x00000000 (bvadd #xffffffff G (bvmul #xffffffff J)))
+     (bvsle #x00000000 (bvadd #xffffffff G (bvmul #xffffffff A)))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff D) E))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff C) H))
+     (bvsle #x00000000 (bvadd G (bvmul #xffffffff I)))
+     (bvsle #x00000000 (bvadd G (bvmul #xffffffff B)))
+     (bvsle #x00000000 (bvadd C (bvmul #xffffffff H)))
+     (bvsle #x00000000 (bvadd #xfffffffd (bvmul #xffffffff F) G)))
+      )
+      (lturn L A B C D E F G H I J K)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) )
+    (=>
+      (and
+        (and (bvsle #x00000000 (bvadd #xfffffffd (bvmul #xffffffff F) B))
+     (bvsle #x00000000 (bvadd #xfffffffd (bvmul #xffffffff L) B))
+     (bvsle #x00000000 (bvadd #xfffffffd G (bvmul #xffffffff L)))
+     (bvsle #x00000000 (bvadd #xfffffffe (bvmul #xffffffff F) I))
+     (bvsle #x00000000 (bvadd #xfffffffe (bvmul #xffffffff A) B))
+     (bvsle #x00000000 (bvadd #xfffffffe (bvmul #xffffffff L) I))
+     (bvsle #x00000000 (bvadd #xfffffffe G (bvmul #xffffffff J)))
+     (bvsle #x00000000 (bvadd #xfffffffe G (bvmul #xffffffff A)))
+     (bvsle #x00000000 (bvadd #xfffffffe B (bvmul #xffffffff J)))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff J) I))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff F) J))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff F) A))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff A) I))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff L) J))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff L) A))
+     (bvsle #x00000000 (bvadd #xffffffff G (bvmul #xffffffff I)))
+     (bvsle #x00000000 (bvadd #xffffffff B (bvmul #xffffffff I)))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff F) L))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff D) E))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff C) H))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff A) J))
+     (bvsle #x00000000 (bvadd G (bvmul #xffffffff B)))
+     (bvsle #x00000000 (bvadd C (bvmul #xffffffff H)))
+     (bvsle #x00000000 (bvadd A (bvmul #xffffffff J)))
+     (bvsle #x00000000 (bvadd #xfffffffd (bvmul #xffffffff F) G)))
+      )
+      (lturn L A B C D E F G H I J K)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) )
+    (=>
+      (and
+        (and (bvsle #x00000000 (bvadd #xfffffffd (bvmul #xffffffff F) B))
+     (bvsle #x00000000 (bvadd #xfffffffd (bvmul #xffffffff L) B))
+     (bvsle #x00000000 (bvadd #xfffffffd G (bvmul #xffffffff L)))
+     (bvsle #x00000000 (bvadd #xfffffffe (bvmul #xffffffff F) I))
+     (bvsle #x00000000 (bvadd #xfffffffe (bvmul #xffffffff F) A))
+     (bvsle #x00000000 (bvadd #xfffffffe (bvmul #xffffffff L) I))
+     (bvsle #x00000000 (bvadd #xfffffffe (bvmul #xffffffff L) A))
+     (bvsle #x00000000 (bvadd #xfffffffe G (bvmul #xffffffff J)))
+     (bvsle #x00000000 (bvadd #xfffffffe B (bvmul #xffffffff J)))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff J) I))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff F) J))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff A) B))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff L) J))
+     (bvsle #x00000000 (bvadd #xffffffff G (bvmul #xffffffff A)))
+     (bvsle #x00000000 (bvadd #xffffffff A (bvmul #xffffffff J)))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff F) L))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff D) E))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff C) H))
+     (bvsle #x00000000 (bvadd G (bvmul #xffffffff I)))
+     (bvsle #x00000000 (bvadd G (bvmul #xffffffff B)))
+     (bvsle #x00000000 (bvadd C (bvmul #xffffffff H)))
+     (bvsle #x00000000 (bvadd #xfffffffd (bvmul #xffffffff F) G)))
+      )
+      (lturn L A B C D E F G H I J K)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) )
+    (=>
+      (and
+        (and (bvsle #x00000000 (bvadd #xfffffffd (bvmul #xffffffff F) B))
+     (bvsle #x00000000 (bvadd #xfffffffd G (bvmul #xffffffff J)))
+     (bvsle #x00000000 (bvadd #xfffffffd B (bvmul #xffffffff J)))
+     (bvsle #x00000000 (bvadd #xfffffffe (bvmul #xffffffff F) A))
+     (bvsle #x00000000 (bvadd #xfffffffe (bvmul #xffffffff L) B))
+     (bvsle #x00000000 (bvadd #xfffffffe G (bvmul #xffffffff L)))
+     (bvsle #x00000000 (bvadd #xfffffffe A (bvmul #xffffffff J)))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff J) I))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff F) I))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff F) L))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff A) B))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff L) A))
+     (bvsle #x00000000 (bvadd #xffffffff G (bvmul #xffffffff I)))
+     (bvsle #x00000000 (bvadd #xffffffff G (bvmul #xffffffff A)))
+     (bvsle #x00000000 (bvadd #xffffffff L (bvmul #xffffffff J)))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff F) J))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff D) E))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff C) H))
+     (bvsle #x00000000 (bvadd G (bvmul #xffffffff B)))
+     (bvsle #x00000000 (bvadd C (bvmul #xffffffff H)))
+     (bvsle #x00000000 (bvadd #xfffffffd (bvmul #xffffffff F) G)))
+      )
+      (lturn L A B C D E F G H I J K)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) )
+    (=>
+      (and
+        (and (bvsle #x00000000 (bvadd #xfffffffd (bvmul #xffffffff F) B))
+     (bvsle #x00000000 (bvadd #xfffffffd (bvmul #xffffffff L) B))
+     (bvsle #x00000000 (bvadd #xfffffffd G (bvmul #xffffffff J)))
+     (bvsle #x00000000 (bvadd #xfffffffd G (bvmul #xffffffff L)))
+     (bvsle #x00000000 (bvadd #xfffffffd B (bvmul #xffffffff J)))
+     (bvsle #x00000000 (bvadd #xfffffffe (bvmul #xffffffff F) A))
+     (bvsle #x00000000 (bvadd #xfffffffe (bvmul #xffffffff L) A))
+     (bvsle #x00000000 (bvadd #xfffffffe G (bvmul #xffffffff I)))
+     (bvsle #x00000000 (bvadd #xfffffffe B (bvmul #xffffffff I)))
+     (bvsle #x00000000 (bvadd #xfffffffe A (bvmul #xffffffff J)))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff J) I))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff F) I))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff A) B))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff L) I))
+     (bvsle #x00000000 (bvadd #xffffffff G (bvmul #xffffffff A)))
+     (bvsle #x00000000 (bvadd #xffffffff A (bvmul #xffffffff I)))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff F) J))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff F) L))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff D) E))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff C) H))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff L) J))
+     (bvsle #x00000000 (bvadd G (bvmul #xffffffff B)))
+     (bvsle #x00000000 (bvadd C (bvmul #xffffffff H)))
+     (bvsle #x00000000 (bvadd L (bvmul #xffffffff J)))
+     (bvsle #x00000000 (bvadd #xfffffffd (bvmul #xffffffff F) G)))
+      )
+      (lturn L A B C D E F G H I J K)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) )
+    (=>
+      (and
+        (and (bvsle #x00000000 (bvadd #xfffffffd (bvmul #xffffffff F) B))
+     (bvsle #x00000000 (bvadd #xfffffffd (bvmul #xffffffff L) B))
+     (bvsle #x00000000 (bvadd #xfffffffd G (bvmul #xffffffff J)))
+     (bvsle #x00000000 (bvadd #xfffffffd G (bvmul #xffffffff L)))
+     (bvsle #x00000000 (bvadd #xfffffffd B (bvmul #xffffffff J)))
+     (bvsle #x00000000 (bvadd #xfffffffe (bvmul #xffffffff A) B))
+     (bvsle #x00000000 (bvadd #xfffffffe G (bvmul #xffffffff I)))
+     (bvsle #x00000000 (bvadd #xfffffffe G (bvmul #xffffffff A)))
+     (bvsle #x00000000 (bvadd #xfffffffe B (bvmul #xffffffff I)))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff J) I))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff F) I))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff F) A))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff L) I))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff L) A))
+     (bvsle #x00000000 (bvadd #xffffffff A (bvmul #xffffffff J)))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff F) J))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff F) L))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff D) E))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff C) H))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff A) I))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff L) J))
+     (bvsle #x00000000 (bvadd G (bvmul #xffffffff B)))
+     (bvsle #x00000000 (bvadd C (bvmul #xffffffff H)))
+     (bvsle #x00000000 (bvadd A (bvmul #xffffffff I)))
+     (bvsle #x00000000 (bvadd L (bvmul #xffffffff J)))
+     (bvsle #x00000000 (bvadd #xfffffffd (bvmul #xffffffff F) G)))
+      )
+      (lturn L A B C D E F G H I J K)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) )
+    (=>
+      (and
+        (and (bvsle #x00000000 (bvadd #xfffffffe (bvmul #xffffffff F) B))
+     (bvsle #x00000000 (bvadd #xfffffffe (bvmul #xffffffff L) B))
+     (bvsle #x00000000 (bvadd #xfffffffe G (bvmul #xffffffff J)))
+     (bvsle #x00000000 (bvadd #xfffffffe G (bvmul #xffffffff L)))
+     (bvsle #x00000000 (bvadd #xfffffffe B (bvmul #xffffffff J)))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff J) I))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff F) I))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff F) A))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff A) B))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff L) I))
+     (bvsle #x00000000 (bvadd #xffffffff (bvmul #xffffffff L) A))
+     (bvsle #x00000000 (bvadd #xffffffff G (bvmul #xffffffff I)))
+     (bvsle #x00000000 (bvadd #xffffffff G (bvmul #xffffffff A)))
+     (bvsle #x00000000 (bvadd #xffffffff B (bvmul #xffffffff I)))
+     (bvsle #x00000000 (bvadd #xffffffff A (bvmul #xffffffff J)))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff F) J))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff F) L))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff D) E))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff C) H))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff A) I))
+     (bvsle #x00000000 (bvadd (bvmul #xffffffff L) J))
+     (bvsle #x00000000 (bvadd G (bvmul #xffffffff B)))
+     (bvsle #x00000000 (bvadd C (bvmul #xffffffff H)))
+     (bvsle #x00000000 (bvadd A (bvmul #xffffffff I)))
+     (bvsle #x00000000 (bvadd L (bvmul #xffffffff J)))
+     (bvsle #x00000000 (bvadd #xfffffffe (bvmul #xffffffff F) G)))
+      )
+      (step_lturn__bar L A B C D E F G H I J K)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) )
+    (=>
+      (and
+        (lturn L A B C D E F G H I J K)
+        true
+      )
+      (combined_lturn L A B C D E F G H I J K)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) )
+    (=>
+      (and
+        (step_lturn L A B C D E F G H I J K)
+        true
+      )
+      (combined_lturn L A B C D E F G H I J K)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) )
+    (=>
+      (and
+        (step_lturn__bar L A B C D E F G H I J K)
+        true
+      )
+      (combined_lturn__bar L A B C D E F G H I J K)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) )
+    (=>
+      (and
+        (step_lturn I A B C D E F G K J L H)
+        true
+      )
+      (lturn I A B C D E F G L K J H)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) )
+    (=>
+      (and
+        (step_lturn__bar I A B C D E F G L J K H)
+        true
+      )
+      (lturn I A B C D E F G L K J H)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (v_12 (_ BitVec 32)) (v_13 (_ BitVec 32)) (v_14 (_ BitVec 32)) )
+    (=>
+      (and
+        (combined_lturn I A B C D E F G v_12 J L H)
+        (step_lturn I A B C D E F G v_13 K J H)
+        (combined_lturn I A B C D E F G v_14 L K H)
+        (and (= v_12 I) (= v_13 I) (= v_14 I))
+      )
+      (lturn I A B C D E F G L K J H)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (v_12 (_ BitVec 32)) (v_13 (_ BitVec 32)) (v_14 (_ BitVec 32)) )
+    (=>
+      (and
+        (combined_lturn I A B C D E F G v_12 J L H)
+        (combined_lturn I A B C D E F G v_13 K J H)
+        (step_lturn I A B C D E F G v_14 L K H)
+        (and (= v_12 I) (= v_13 I) (= v_14 I))
+      )
+      (lturn I A B C D E F G L K J H)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (v_12 (_ BitVec 32)) (v_13 (_ BitVec 32)) (v_14 (_ BitVec 32)) )
+    (=>
+      (and
+        (step_lturn I A B C D E F G v_12 J L H)
+        (combined_lturn I A B C D E F G v_13 K J H)
+        (combined_lturn I A B C D E F G v_14 L K H)
+        (and (= v_12 I) (= v_13 I) (= v_14 I))
+      )
+      (lturn I A B C D E F G L K J H)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (M (_ BitVec 32)) (v_13 (_ BitVec 32)) (v_14 (_ BitVec 32)) (v_15 (_ BitVec 32)) )
+    (=>
+      (and
+        (combined_lturn J A B C D E F G I L v_13 H)
+        (step_lturn J A B C D E F G M L K H)
+        (combined_lturn J A B C D E F G v_14 L K H)
+        (combined_lturn J A B C D E F G v_15 M L H)
+        (combined_lturn J A B C D E F G I M L H)
+        (and (= v_13 J) (= v_14 J) (= v_15 J))
+      )
+      (lturn J A B C D E F G I L K H)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (M (_ BitVec 32)) (v_13 (_ BitVec 32)) (v_14 (_ BitVec 32)) (v_15 (_ BitVec 32)) )
+    (=>
+      (and
+        (combined_lturn J A B C D E F G I L v_13 H)
+        (combined_lturn J A B C D E F G M L K H)
+        (step_lturn J A B C D E F G v_14 L K H)
+        (combined_lturn J A B C D E F G v_15 M L H)
+        (combined_lturn J A B C D E F G I M L H)
+        (and (= v_13 J) (= v_14 J) (= v_15 J))
+      )
+      (lturn J A B C D E F G I L K H)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (M (_ BitVec 32)) (v_13 (_ BitVec 32)) (v_14 (_ BitVec 32)) (v_15 (_ BitVec 32)) )
+    (=>
+      (and
+        (combined_lturn J A B C D E F G I L v_13 H)
+        (combined_lturn J A B C D E F G M L K H)
+        (combined_lturn J A B C D E F G v_14 L K H)
+        (step_lturn J A B C D E F G v_15 M L H)
+        (combined_lturn J A B C D E F G I M L H)
+        (and (= v_13 J) (= v_14 J) (= v_15 J))
+      )
+      (lturn J A B C D E F G I L K H)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (M (_ BitVec 32)) (v_13 (_ BitVec 32)) (v_14 (_ BitVec 32)) (v_15 (_ BitVec 32)) )
+    (=>
+      (and
+        (combined_lturn J A B C D E F G I L v_13 H)
+        (combined_lturn J A B C D E F G M L K H)
+        (combined_lturn J A B C D E F G v_14 L K H)
+        (combined_lturn J A B C D E F G v_15 M L H)
+        (step_lturn J A B C D E F G I M L H)
+        (and (= v_13 J) (= v_14 J) (= v_15 J))
+      )
+      (lturn J A B C D E F G I L K H)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (M (_ BitVec 32)) (v_13 (_ BitVec 32)) (v_14 (_ BitVec 32)) (v_15 (_ BitVec 32)) )
+    (=>
+      (and
+        (step_lturn J A B C D E F G I L v_13 H)
+        (combined_lturn J A B C D E F G M L K H)
+        (combined_lturn J A B C D E F G v_14 L K H)
+        (combined_lturn J A B C D E F G v_15 M L H)
+        (combined_lturn J A B C D E F G I M L H)
+        (and (= v_13 J) (= v_14 J) (= v_15 J))
+      )
+      (lturn J A B C D E F G I L K H)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) )
+    (=>
+      (and
+        (step_lturn I A B C D E F G K J L H)
+        true
+      )
+      (step_lturn I A B C D E F G L K J H)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) )
+    (=>
+      (and
+        (step_lturn__bar I A B C D E F G L J K H)
+        true
+      )
+      (step_lturn I A B C D E F G L K J H)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (v_12 (_ BitVec 32)) (v_13 (_ BitVec 32)) (v_14 (_ BitVec 32)) )
+    (=>
+      (and
+        (combined_lturn I A B C D E F G v_12 J L H)
+        (step_lturn I A B C D E F G v_13 K J H)
+        (combined_lturn I A B C D E F G v_14 L K H)
+        (and (= v_12 I) (= v_13 I) (= v_14 I))
+      )
+      (step_lturn I A B C D E F G L K J H)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (v_12 (_ BitVec 32)) (v_13 (_ BitVec 32)) (v_14 (_ BitVec 32)) )
+    (=>
+      (and
+        (combined_lturn I A B C D E F G v_12 J L H)
+        (combined_lturn I A B C D E F G v_13 K J H)
+        (step_lturn I A B C D E F G v_14 L K H)
+        (and (= v_12 I) (= v_13 I) (= v_14 I))
+      )
+      (step_lturn I A B C D E F G L K J H)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (v_12 (_ BitVec 32)) (v_13 (_ BitVec 32)) (v_14 (_ BitVec 32)) )
+    (=>
+      (and
+        (step_lturn I A B C D E F G v_12 J L H)
+        (combined_lturn I A B C D E F G v_13 K J H)
+        (combined_lturn I A B C D E F G v_14 L K H)
+        (and (= v_12 I) (= v_13 I) (= v_14 I))
+      )
+      (step_lturn I A B C D E F G L K J H)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (M (_ BitVec 32)) (v_13 (_ BitVec 32)) (v_14 (_ BitVec 32)) (v_15 (_ BitVec 32)) )
+    (=>
+      (and
+        (combined_lturn J A B C D E F G I L v_13 H)
+        (step_lturn J A B C D E F G M L K H)
+        (combined_lturn J A B C D E F G v_14 L K H)
+        (combined_lturn J A B C D E F G v_15 M L H)
+        (combined_lturn J A B C D E F G I M L H)
+        (and (= v_13 J) (= v_14 J) (= v_15 J))
+      )
+      (step_lturn J A B C D E F G I L K H)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (M (_ BitVec 32)) (v_13 (_ BitVec 32)) (v_14 (_ BitVec 32)) (v_15 (_ BitVec 32)) )
+    (=>
+      (and
+        (combined_lturn J A B C D E F G I L v_13 H)
+        (combined_lturn J A B C D E F G M L K H)
+        (step_lturn J A B C D E F G v_14 L K H)
+        (combined_lturn J A B C D E F G v_15 M L H)
+        (combined_lturn J A B C D E F G I M L H)
+        (and (= v_13 J) (= v_14 J) (= v_15 J))
+      )
+      (step_lturn J A B C D E F G I L K H)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (M (_ BitVec 32)) (v_13 (_ BitVec 32)) (v_14 (_ BitVec 32)) (v_15 (_ BitVec 32)) )
+    (=>
+      (and
+        (combined_lturn J A B C D E F G I L v_13 H)
+        (combined_lturn J A B C D E F G M L K H)
+        (combined_lturn J A B C D E F G v_14 L K H)
+        (step_lturn J A B C D E F G v_15 M L H)
+        (combined_lturn J A B C D E F G I M L H)
+        (and (= v_13 J) (= v_14 J) (= v_15 J))
+      )
+      (step_lturn J A B C D E F G I L K H)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (M (_ BitVec 32)) (v_13 (_ BitVec 32)) (v_14 (_ BitVec 32)) (v_15 (_ BitVec 32)) )
+    (=>
+      (and
+        (combined_lturn J A B C D E F G I L v_13 H)
+        (combined_lturn J A B C D E F G M L K H)
+        (combined_lturn J A B C D E F G v_14 L K H)
+        (combined_lturn J A B C D E F G v_15 M L H)
+        (step_lturn J A B C D E F G I M L H)
+        (and (= v_13 J) (= v_14 J) (= v_15 J))
+      )
+      (step_lturn J A B C D E F G I L K H)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (M (_ BitVec 32)) (v_13 (_ BitVec 32)) (v_14 (_ BitVec 32)) (v_15 (_ BitVec 32)) )
+    (=>
+      (and
+        (step_lturn J A B C D E F G I L v_13 H)
+        (combined_lturn J A B C D E F G M L K H)
+        (combined_lturn J A B C D E F G v_14 L K H)
+        (combined_lturn J A B C D E F G v_15 M L H)
+        (combined_lturn J A B C D E F G I M L H)
+        (and (= v_13 J) (= v_14 J) (= v_15 J))
+      )
+      (step_lturn J A B C D E F G I L K H)
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (M (_ BitVec 32)) (v_13 (_ BitVec 32)) (v_14 (_ BitVec 32)) (v_15 (_ BitVec 32)) )
+    (=>
+      (and
+        (combined_lturn J A B C D E F G I L v_13 H)
+        (step_lturn J A B C D E F G I K L H)
+        (combined_lturn J A B C D E F G M L K H)
+        (combined_lturn J A B C D E F G v_14 L K H)
+        (combined_lturn J A B C D E F G v_15 M L H)
+        (combined_lturn J A B C D E F G I M L H)
+        (and (= v_13 J) (= v_14 J) (= v_15 J))
+      )
+      CHC_COMP_FALSE
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (M (_ BitVec 32)) (v_13 (_ BitVec 32)) (v_14 (_ BitVec 32)) (v_15 (_ BitVec 32)) )
+    (=>
+      (and
+        (step_lturn J A B C D E F G I L v_13 H)
+        (combined_lturn J A B C D E F G I K L H)
+        (combined_lturn J A B C D E F G M L K H)
+        (combined_lturn J A B C D E F G v_14 L K H)
+        (combined_lturn J A B C D E F G v_15 M L H)
+        (combined_lturn J A B C D E F G I M L H)
+        (and (= v_13 J) (= v_14 J) (= v_15 J))
+      )
+      CHC_COMP_FALSE
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (M (_ BitVec 32)) (v_13 (_ BitVec 32)) (v_14 (_ BitVec 32)) (v_15 (_ BitVec 32)) )
+    (=>
+      (and
+        (combined_lturn J A B C D E F G I L v_13 H)
+        (combined_lturn J A B C D E F G I K L H)
+        (combined_lturn J A B C D E F G M L K H)
+        (combined_lturn J A B C D E F G v_14 L K H)
+        (combined_lturn J A B C D E F G v_15 M L H)
+        (step_lturn J A B C D E F G I M L H)
+        (and (= v_13 J) (= v_14 J) (= v_15 J))
+      )
+      CHC_COMP_FALSE
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (M (_ BitVec 32)) (v_13 (_ BitVec 32)) (v_14 (_ BitVec 32)) (v_15 (_ BitVec 32)) )
+    (=>
+      (and
+        (combined_lturn J A B C D E F G I L v_13 H)
+        (combined_lturn J A B C D E F G I K L H)
+        (combined_lturn J A B C D E F G M L K H)
+        (combined_lturn J A B C D E F G v_14 L K H)
+        (step_lturn J A B C D E F G v_15 M L H)
+        (combined_lturn J A B C D E F G I M L H)
+        (and (= v_13 J) (= v_14 J) (= v_15 J))
+      )
+      CHC_COMP_FALSE
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (M (_ BitVec 32)) (v_13 (_ BitVec 32)) (v_14 (_ BitVec 32)) (v_15 (_ BitVec 32)) )
+    (=>
+      (and
+        (combined_lturn J A B C D E F G I L v_13 H)
+        (combined_lturn J A B C D E F G I K L H)
+        (combined_lturn J A B C D E F G M L K H)
+        (step_lturn J A B C D E F G v_14 L K H)
+        (combined_lturn J A B C D E F G v_15 M L H)
+        (combined_lturn J A B C D E F G I M L H)
+        (and (= v_13 J) (= v_14 J) (= v_15 J))
+      )
+      CHC_COMP_FALSE
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (M (_ BitVec 32)) (v_13 (_ BitVec 32)) (v_14 (_ BitVec 32)) (v_15 (_ BitVec 32)) )
+    (=>
+      (and
+        (combined_lturn J A B C D E F G I L v_13 H)
+        (combined_lturn J A B C D E F G I K L H)
+        (step_lturn J A B C D E F G M L K H)
+        (combined_lturn J A B C D E F G v_14 L K H)
+        (combined_lturn J A B C D E F G v_15 M L H)
+        (combined_lturn J A B C D E F G I M L H)
+        (and (= v_13 J) (= v_14 J) (= v_15 J))
+      )
+      CHC_COMP_FALSE
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (v_12 (_ BitVec 32)) (v_13 (_ BitVec 32)) (v_14 (_ BitVec 32)) )
+    (=>
+      (and
+        (combined_lturn I A B C D E F G v_12 J L H)
+        (step_lturn I A B C D E F G L J K H)
+        (combined_lturn I A B C D E F G v_13 K J H)
+        (combined_lturn I A B C D E F G v_14 L K H)
+        (and (= v_12 I) (= v_13 I) (= v_14 I))
+      )
+      CHC_COMP_FALSE
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (v_12 (_ BitVec 32)) (v_13 (_ BitVec 32)) (v_14 (_ BitVec 32)) )
+    (=>
+      (and
+        (step_lturn I A B C D E F G v_12 J L H)
+        (combined_lturn I A B C D E F G L J K H)
+        (combined_lturn I A B C D E F G v_13 K J H)
+        (combined_lturn I A B C D E F G v_14 L K H)
+        (and (= v_12 I) (= v_13 I) (= v_14 I))
+      )
+      CHC_COMP_FALSE
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (v_12 (_ BitVec 32)) (v_13 (_ BitVec 32)) (v_14 (_ BitVec 32)) )
+    (=>
+      (and
+        (combined_lturn I A B C D E F G v_12 J L H)
+        (combined_lturn I A B C D E F G L J K H)
+        (combined_lturn I A B C D E F G v_13 K J H)
+        (step_lturn I A B C D E F G v_14 L K H)
+        (and (= v_12 I) (= v_13 I) (= v_14 I))
+      )
+      CHC_COMP_FALSE
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) (v_12 (_ BitVec 32)) (v_13 (_ BitVec 32)) (v_14 (_ BitVec 32)) )
+    (=>
+      (and
+        (combined_lturn I A B C D E F G v_12 J L H)
+        (combined_lturn I A B C D E F G L J K H)
+        (step_lturn I A B C D E F G v_13 K J H)
+        (combined_lturn I A B C D E F G v_14 L K H)
+        (and (= v_12 I) (= v_13 I) (= v_14 I))
+      )
+      CHC_COMP_FALSE
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) )
+    (=>
+      (and
+        (combined_lturn I A B C D E F G L K J H)
+        (step_lturn I A B C D E F G L J K H)
+        true
+      )
+      CHC_COMP_FALSE
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) )
+    (=>
+      (and
+        (step_lturn I A B C D E F G L K J H)
+        (combined_lturn I A B C D E F G L J K H)
+        true
+      )
+      CHC_COMP_FALSE
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) )
+    (=>
+      (and
+        (combined_lturn__bar I A B C D E F G L K J H)
+        (step_lturn I A B C D E F G L K J H)
+        true
+      )
+      CHC_COMP_FALSE
+    )
+  )
+)
+(assert
+  (forall ( (A (_ BitVec 32)) (B (_ BitVec 32)) (C (_ BitVec 32)) (D (_ BitVec 32)) (E (_ BitVec 32)) (F (_ BitVec 32)) (G (_ BitVec 32)) (H (_ BitVec 32)) (I (_ BitVec 32)) (J (_ BitVec 32)) (K (_ BitVec 32)) (L (_ BitVec 32)) )
+    (=>
+      (and
+        (step_lturn__bar I A B C D E F G L K J H)
+        (combined_lturn I A B C D E F G L K J H)
+        true
+      )
+      CHC_COMP_FALSE
+    )
+  )
+)
+(assert
+  (forall ( (CHC_COMP_UNUSED Bool) )
+    (=>
+      (and
+        CHC_COMP_FALSE
+      )
+      false
+    )
+  )
+)
+
+(check-sat)
+(exit)

From 8d7d0e89c027541a2a4a684aadb2bd13bec18694 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Sun, 31 May 2026 18:26:35 +0200
Subject: [PATCH 28/77] eldarica horn converter: fix parameter as constraint
 rewriting

Took me 2 days to find it...
---
 .../solvers/princess/eldarica/PrincessHornConverter.java         | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
index 8293eb5eed..606042d7c3 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -106,7 +106,6 @@ private Clause toClause(final IAtom head, final IIntFormula rest) {
 
     private Clause toClause(final IAtom head, final IBinFormula rest) {
       List<IAtom> body = new ArrayList<>();
-      IFormula constraint = this.constraint;
 
       for (IFormula and : flatten(rest)) {
         if (and instanceof IAtom) {

From 8e3ab2cced797655484af840ab0c03b27f987fb7 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Sun, 31 May 2026 19:42:57 +0200
Subject: [PATCH 29/77] fix all the conversion errors

Tests are all passing
---
 .../solvers/princess/EldaricaHornProver.java  |  5 --
 .../eldarica/PrincessHornConverter.java       | 49 +++++++++++++++----
 .../java_smt/test/horn/HornExampleTest.java   | 26 ++--------
 3 files changed, 45 insertions(+), 35 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
index 6547988937..ac37ba3e73 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
@@ -74,11 +74,6 @@ private void addConstraint1(BooleanFormula constraint) {
 
     var clause = converter.toClause(assertion);
 
-    clause.constants();
-    clause.constants();
-    clause.constants();
-    clause.constants();
-
     this.clauses.add(clause);
   }
 
diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
index 606042d7c3..ac8ba75082 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -32,6 +32,8 @@
 import ap.terfor.conjunctions.Quantifier.ALL$;
 import ap.terfor.preds.Predicate;
 import ap.types.MonoSortedIFunction;
+import ap.types.Sort.Integer$;
+import ap.types.SortedConstantTerm;
 import java.util.ArrayList;
 import java.util.List;
 import lazabs.horn.bottomup.HornClauses;
@@ -108,8 +110,8 @@ private Clause toClause(final IAtom head, final IBinFormula rest) {
       List<IAtom> body = new ArrayList<>();
 
       for (IFormula and : flatten(rest)) {
-        if (and instanceof IAtom) {
-          body.add((IAtom) and);
+        if (and instanceof IAtom atom && atom.args().isEmpty()) {
+          body.add(new IAtom(atom.pred(), toTerm(atom.args())));
           continue;
         }
         if (and instanceof IIntFormula) {
@@ -152,6 +154,9 @@ private Clause toClause(final IAtom head, final IFormula rest) {
     }
 
     private IConstant addConstraint(final ITerm term) {
+      if (term instanceof IConstant) {
+        return (IConstant) term;
+      }
       var variable = new IConstant(new ConstantTerm("T" + ++variables));
       var constraint = new IEquation(variable, term);
 
@@ -160,12 +165,27 @@ private IConstant addConstraint(final ITerm term) {
       return variable;
     }
 
+    private IAtom toFormula(final IAtom atom) {
+      return new IAtom(atom.pred(), toTerm(atom.args()));
+    }
+
+    private IIntFormula toFormula(final IIntFormula i) {
+      return new IIntFormula(i.rel(), toTerm(i.t()));
+    }
+
+    private IEquation toFormula(final IEquation equation) {
+      return new IEquation(toTerm(equation.left()), toTerm(equation.right()));
+    }
+
     private IFormula toFormula(final IFormula formula) {
+      if (formula instanceof IAtom atom) {
+        return toFormula(atom);
+      }
       if (formula instanceof IIntFormula i) {
-        return new IIntFormula(i.rel(), toTerm(i.t()));
+        return toFormula(i);
       }
       if (formula instanceof IEquation equation) {
-        return new IEquation(toTerm(equation.left()), toTerm(equation.right()));
+        return toFormula(equation);
       }
 
       return formula;
@@ -174,13 +194,21 @@ private IFormula toFormula(final IFormula formula) {
     private IConstant toVariable(final ISortedVariable variable) {
       var name = "V" + variable.index();
 
-      for(IConstant constant : parameters) {
-        if(constant.c().name().equals(name)) {
+      for (IConstant constant : parameters) {
+        if (constant.c().name().equals(name)) {
           return constant;
         }
       }
 
-      var constant = new IConstant(new ConstantTerm(name));
+      ConstantTerm term;
+
+      if (variable.sort() == Integer$.MODULE$) {
+        term = new ConstantTerm(name);
+      } else {
+        term = new SortedConstantTerm(name, variable.sort());
+      }
+
+      var constant = new IConstant(term);
       parameters.add(constant);
       return constant;
     }
@@ -214,6 +242,9 @@ private ITerm toConstraint(final ITerm term) {
       if (term instanceof ISortedVariable variable) {
         return toVariable(variable);
       }
+      if (term instanceof IFunApp fun) {
+        return addConstraint(new IFunApp(fun.fun(), toTerm(fun.args())));
+      }
       return addConstraint(toTerm(term));
     }
 
@@ -271,8 +302,8 @@ private Clause toClause(final IBinFormula input) {
 
       IAtom head;
 
-      if (other instanceof IAtom) {
-        head = (IAtom) other;
+      if (other instanceof IAtom atom) {
+        head = toFormula(atom);
       } else if (other instanceof IIntFormula) {
         head = toAtom((IIntFormula) other);
         if (head == null) {
diff --git a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
index 8687e67f4d..a5edc5207d 100644
--- a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
+++ b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
@@ -13,7 +13,6 @@
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
-import lazabs.GlobalParameters;
 import org.junit.Test;
 import org.sosy_lab.java_smt.SolverContextFactory;
 import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
@@ -22,26 +21,12 @@
 import org.sosy_lab.java_smt.test.Yes;
 
 public class HornExampleTest {
-  public void booleanJavaSMT() throws Exception {
-    final var context = SolverContextFactory.createSolverContext(Solvers.PRINCESS);
+  // TODO: Test with all solvers, not just eldarica (ParameterizedSolverBasedTest0)
 
-    var formulas = context.getFormulaManager();
-
-    var varA = formulas.getIntegerFormulaManager().makeVariable("a");
-    var varB = formulas.getIntegerFormulaManager().makeVariable("b");
-    var varC = formulas.getIntegerFormulaManager().makeNumber(5);
-
-    var formular1 = formulas.getIntegerFormulaManager().equal(varA, varB);
-    var formular2 = formulas.getIntegerFormulaManager().greaterOrEquals(varA, varC);
-
-    var formular = formulas.getBooleanFormulaManager().and(formular1, formular2);
-
-    var prover = context.newProverEnvironment();
-
-    prover.addConstraint(formular);
-
-    assertFalse(prover.isUnsat());
-  }
+  // static {
+  //   GlobalParameters.get().setLogLevel(3);
+  //   GlobalParameters.get().log_$eq(true);
+  // }
 
   @Test
   public void hornJavaSMT() throws Exception {
@@ -183,7 +168,6 @@ public void smt_ch_triangle_location_nr_2_bv_000() throws Exception {
 
   @Test
   public void smt_small_unsat() throws Exception {
-    GlobalParameters.get().setLogLevel(3);
     /*
     mc(A,B) :- ((A + -100) >= 1),(B = (A + -10)).
     mc(A,B) :- (A =< 100),mc(C,B),(D = (A + 11)),mc(D,C).

From 0e6ef01d65faf9efc97957fbdfeadaa0c67470ac Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Sat, 6 Jun 2026 14:32:43 +0200
Subject: [PATCH 30/77] cmdline: Allow specifying prover environment, fixes

---
 .../java_smt/cmdline/CmdLineArguments.java    |  3 ++
 .../java_smt/cmdline/JavaSMTMain.java         | 34 ++++++++++++++++---
 2 files changed, 32 insertions(+), 5 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/cmdline/CmdLineArguments.java b/src/org/sosy_lab/java_smt/cmdline/CmdLineArguments.java
index f2de975f3c..aa19a0f3bb 100644
--- a/src/org/sosy_lab/java_smt/cmdline/CmdLineArguments.java
+++ b/src/org/sosy_lab/java_smt/cmdline/CmdLineArguments.java
@@ -31,6 +31,9 @@ private CmdLineArguments() {}
           new CmdLineArgument1("--solver", "-solver")
               .settingOption("solver.solver")
               .withDescription("Set SMT solver to use"),
+          new CmdLineArgument1("--environment", "-environment")
+              .settingOption("solver.environment")
+              .withDescription("Set the prover environemnt to use"),
           new CmdLineArgument1("--logic", "-logic")
               .settingOption("solver.opensmt.logic")
               .withDescription("Set SMT logic (only for OpenSMT)"),
diff --git a/src/org/sosy_lab/java_smt/cmdline/JavaSMTMain.java b/src/org/sosy_lab/java_smt/cmdline/JavaSMTMain.java
index d2496bcccd..61fd171d01 100644
--- a/src/org/sosy_lab/java_smt/cmdline/JavaSMTMain.java
+++ b/src/org/sosy_lab/java_smt/cmdline/JavaSMTMain.java
@@ -32,11 +32,12 @@
 import org.sosy_lab.common.log.LogManager;
 import org.sosy_lab.java_smt.SolverContextFactory;
 import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
+import org.sosy_lab.java_smt.api.BasicProverEnvironment;
 import org.sosy_lab.java_smt.api.BooleanFormula;
 import org.sosy_lab.java_smt.api.FormulaManager;
-import org.sosy_lab.java_smt.api.ProverEnvironment;
 import org.sosy_lab.java_smt.api.SolverContext;
 import org.sosy_lab.java_smt.api.SolverException;
+import org.sosy_lab.java_smt.cmdline.JavaSMTMain.MainOptions.Environments;
 
 /**
  * Main entry point for JavaSMT command-line interface. Executes SMT2 files using a selected solver
@@ -57,7 +58,7 @@ public static void main(String[] args) {
     Locale.setDefault(Locale.US);
 
     if (args.length == 0) {
-      args = new String[] {"--help"};
+      args = new String[]{"--help"};
     }
 
     final Configuration config;
@@ -114,6 +115,16 @@ private MainOptions(Configuration config) throws InvalidConfigurationException {
 
     @Option(secure = true, name = "solver.solver", description = "The SMT solver to use")
     private Solvers solver = Solvers.SMTINTERPOL;
+
+    @Option(secure = true, name = "solver.environment", description = "The prover environment use")
+    private Environments environment = Environments.DEFAULT;
+
+    enum Environments {
+      DEFAULT,
+      HORN,
+      OPTIMIZATION,
+      INTERPOLATION,
+    }
   }
 
   /**
@@ -136,6 +147,17 @@ public static Configuration createConfiguration(Map<String, String> cmdLineOptio
     return config;
   }
 
+  private static BasicProverEnvironment<?> createProverEnvironment(
+      Environments type,
+      SolverContext context) {
+    return switch (type) {
+      case DEFAULT -> context.newProverEnvironment();
+      case OPTIMIZATION -> context.newOptimizationProverEnvironment();
+      case INTERPOLATION -> context.newProverEnvironmentWithInterpolation();
+      case HORN -> context.newHornProverEnvironment();
+    };
+  }
+
   private static void run(Configuration config, LogManager logManager, MainOptions options) {
 
     String input;
@@ -149,8 +171,9 @@ private static void run(Configuration config, LogManager logManager, MainOptions
     ShutdownNotifier notifier = shutdownManager.getNotifier();
 
     try (SolverContext context =
-            SolverContextFactory.createSolverContext(config, logManager, notifier, options.solver);
-        ProverEnvironment prover = context.newProverEnvironment()) {
+             SolverContextFactory.createSolverContext(config, logManager, notifier, options.solver);
+         BasicProverEnvironment<?> prover = createProverEnvironment(options.environment,
+             context)) {
 
       FormulaManager formulaManager = context.getFormulaManager();
       List<BooleanFormula> formulas = formulaManager.parseAll(input);
@@ -175,5 +198,6 @@ private static void run(Configuration config, LogManager logManager, MainOptions
     }
   }
 
-  private JavaSMTMain() {}
+  private JavaSMTMain() {
+  }
 }

From 32eefc05a4205570583013f5b761533af8fb38b4 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Tue, 9 Jun 2026 19:55:21 +0200
Subject: [PATCH 31/77] remove unused imports

---
 .idea/misc.xml                                                   | 1 -
 .../sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java   | 1 -
 src/org/sosy_lab/java_smt/test/EldaricaHornProverTest.java       | 1 -
 3 files changed, 3 deletions(-)

diff --git a/.idea/misc.xml b/.idea/misc.xml
index 2a7daed4f3..63eb8e917c 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,4 +1,3 @@
-<?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="EntryPointsManager">
     <entry_points version="2.0" />
diff --git a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
index ac37ba3e73..e6bf9ca939 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
@@ -20,7 +20,6 @@
 import java.util.Set;
 import lazabs.horn.CEGARHornWrapper;
 import lazabs.horn.HornAPI;
-import lazabs.horn.HornWrapper;
 import lazabs.horn.Util.Dag;
 import lazabs.horn.abstractions.EmptyVerificationHints$;
 import lazabs.horn.bottomup.HornClauses.Clause;
diff --git a/src/org/sosy_lab/java_smt/test/EldaricaHornProverTest.java b/src/org/sosy_lab/java_smt/test/EldaricaHornProverTest.java
index 94872b4b9e..79621e926f 100644
--- a/src/org/sosy_lab/java_smt/test/EldaricaHornProverTest.java
+++ b/src/org/sosy_lab/java_smt/test/EldaricaHornProverTest.java
@@ -32,7 +32,6 @@
 import ap.types.Sort.Integer$;
 import java.util.Arrays;
 import org.junit.Test;
-import org.sosy_lab.java_smt.solvers.princess.EldaricaHornProver;
 import org.sosy_lab.java_smt.solvers.princess.eldarica.PrincessHornConverter;
 import scala.collection.immutable.Seq;
 import scala.collection.immutable.Seq$;

From a10c9e52bb228d1e57659c292887461bf9a32740 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Tue, 9 Jun 2026 20:29:00 +0200
Subject: [PATCH 32/77] eldarica converter: convert body to constraint instead
 of crashing

---
 .../eldarica/PrincessHornConverter.java         | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
index ac8ba75082..947a343fd5 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -73,7 +73,7 @@ private List<IFormula> flatten(final IBinFormula input) {
         return flattenAnd(input);
       }
 
-      throw new IllegalArgumentException("Illegal horn clause: " + input);
+      return List.of(toFormula(input));
     }
 
     private List<IFormula> flattenAnd(final IBinFormula input) {
@@ -177,6 +177,15 @@ private IEquation toFormula(final IEquation equation) {
       return new IEquation(toTerm(equation.left()), toTerm(equation.right()));
     }
 
+    private IBinFormula toFormula(final IBinFormula bin) {
+      return new IBinFormula(bin.j(), toFormula(bin.f1()),
+          toFormula(bin.f2()));
+    }
+
+    private INot toFormula(final INot not) {
+      return new INot(toFormula(not.subformula()));
+    }
+
     private IFormula toFormula(final IFormula formula) {
       if (formula instanceof IAtom atom) {
         return toFormula(atom);
@@ -187,6 +196,12 @@ private IFormula toFormula(final IFormula formula) {
       if (formula instanceof IEquation equation) {
         return toFormula(equation);
       }
+      if (formula instanceof IBinFormula bin) {
+        return toFormula(bin);
+      }
+      if (formula instanceof INot bin) {
+        return toFormula(bin);
+      }
 
       return formula;
     }

From b676efd5b2161bdc4810382b64f037f7cd5edc4b Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Tue, 9 Jun 2026 20:46:26 +0200
Subject: [PATCH 33/77] another set of robustness/error handling

---
 .../eldarica/PrincessHornConverter.java       | 32 +++++++++----------
 1 file changed, 15 insertions(+), 17 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
index 947a343fd5..e24e822418 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -89,7 +89,7 @@ private List<IFormula> flatten(final IFormula input) {
         return flatten((IBinFormula) input);
       }
 
-      return List.of(input);
+      return List.of(toFormula(input));
     }
 
     private Clause toClause(final IAtom head, final IAtom rest) {
@@ -103,7 +103,9 @@ private Clause toClause(final IAtom head, final IIntFormula rest) {
         return new Clause(head, CollectionConverters.asScala(List.of(atom)).toList(),
             this.constraint);
       }
-      return new Clause(head, List$.MODULE$.empty(), this.constraint.andSimplify(toFormula(rest)));
+      // TODO: Is that duplicating the constraint?
+      this.constraint = this.constraint.andSimplify(toFormula(rest));
+      return new Clause(head, List$.MODULE$.empty(), this.constraint);
     }
 
     private Clause toClause(final IAtom head, final IBinFormula rest) {
@@ -129,15 +131,6 @@ private Clause toClause(final IAtom head, final IBinFormula rest) {
       return new Clause(head, CollectionConverters.asScala(body).toList(), constraint);
     }
 
-    private Clause toClause(final IAtom head, final IFormula rest, final IFormula constraint) {
-      // INPUT: ((B1 = 0) & C2) ; constraint: C1
-      // CLAUSE: Clause(FALSE, List(B1), (C2 & !C1))
-      var clause = toClause(head, rest);
-
-      return new Clause(clause.head(), clause.body(), new IBinFormula(IBinJunctor.And(),
-          clause.constraint(), this.constraint.andSimplify(new INot(constraint))));
-    }
-
     private Clause toClause(final IAtom head, final IFormula rest) {
       if (rest instanceof IAtom) {
         return toClause(head, (IAtom) rest);
@@ -145,7 +138,6 @@ private Clause toClause(final IAtom head, final IFormula rest) {
       if (rest instanceof IIntFormula) {
         return toClause(head, (IIntFormula) rest);
       }
-
       if (rest instanceof IBinFormula) {
         return toClause(head, (IBinFormula) rest);
       }
@@ -182,8 +174,8 @@ private IBinFormula toFormula(final IBinFormula bin) {
           toFormula(bin.f2()));
     }
 
-    private INot toFormula(final INot not) {
-      return new INot(toFormula(not.subformula()));
+    private IFormula toFormula(final INot not) {
+      return toFormula(not.subformula()).notSimplify();
     }
 
     private IFormula toFormula(final IFormula formula) {
@@ -236,6 +228,9 @@ private ITerm toTerm(final ITerm term) {
       if (term instanceof IIntLit lit) {
         return lit;
       }
+      if(term instanceof IConstant constant) {
+        return constant;
+      }
       if (term instanceof ISortedVariable variable) {
         return toVariable(variable);
       }
@@ -245,9 +240,11 @@ private ITerm toTerm(final ITerm term) {
       if (term instanceof ITimes times) {
         return new ITimes(times.coeff(), toTerm(times.subterm()));
       }
-      // TODO: epsilon, ITermITE, function
+      if(term instanceof IFunApp fun) {
+        return new IFunApp(fun.fun(), toTerm(fun.args()));
+      }
 
-      return term;
+      throw new IllegalArgumentException("Unhandled term: " + term);
     }
 
     private ITerm toConstraint(final ITerm term) {
@@ -326,10 +323,11 @@ private Clause toClause(final IBinFormula input) {
         }
       } else {
         head = new IAtom(HornClauses.FALSE(), (Seq<ITerm>) Seq$.MODULE$.empty());
+        this.constraint = this.constraint.andSimplify(toFormula(other).notSimplify());
 
         // TODO: (expected) Clause(FALSE,List(mc(P1, P0)),!(!((101 + -1 * P1) >= 0) | (P0 = 92)))
         // TODO: (actual  ) Clause(FALSE,List(mc(P1, P0)),(((101 + -1 * P1) >= 0) & !(P0 = 91)))
-        return toClause(head, not.subformula(), toFormula(other));
+        return toClause(head, not.subformula());
       }
 
 

From 9b871cd60f49000e545bd928beebb091242828d5 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Tue, 9 Jun 2026 21:16:52 +0200
Subject: [PATCH 34/77] main class in manifest

---
 src/META-INF/MANIFEST.MF | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 src/META-INF/MANIFEST.MF

diff --git a/src/META-INF/MANIFEST.MF b/src/META-INF/MANIFEST.MF
new file mode 100644
index 0000000000..c16a029951
--- /dev/null
+++ b/src/META-INF/MANIFEST.MF
@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+Main-Class: org.sosy_lab.java_smt.cmdline.JavaSMTMain
+

From 7350c89cba3375c20ac8fb5df4f6755c36a24740 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Mon, 15 Jun 2026 15:15:15 +0200
Subject: [PATCH 35/77] fix bad import :)

---
 src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
index a5edc5207d..a90942ff86 100644
--- a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
+++ b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
@@ -18,7 +18,6 @@
 import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
 import org.sosy_lab.java_smt.api.FormulaType;
 import org.sosy_lab.java_smt.api.HornProverEnvironment;
-import org.sosy_lab.java_smt.test.Yes;
 
 public class HornExampleTest {
   // TODO: Test with all solvers, not just eldarica (ParameterizedSolverBasedTest0)
@@ -127,7 +126,7 @@ public void hornJavaSMTPredicate() throws Exception {
 
   private HornProverEnvironment solveSmtLib2(final String file) throws Exception {
     var input =
-        new String(Yes.class.getResourceAsStream("/org/sosy_lab/java_smt/test/horn/" + file +
+        new String(HornExampleTest.class.getResourceAsStream("/org/sosy_lab/java_smt/test/horn/" + file +
             ".smt2").readAllBytes());
 
     final var context = SolverContextFactory.createSolverContext(Solvers.ELDARICA);

From ff7a6cefd09c9807a62e709803332d9d2d58b98c Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Fri, 19 Jun 2026 13:27:01 +0200
Subject: [PATCH 36/77] eldarica: horn: ITermITE

---
 .../solvers/princess/eldarica/PrincessHornConverter.java      | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
index e24e822418..d36c798b11 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -27,6 +27,7 @@
 import ap.parser.ISortedQuantified;
 import ap.parser.ISortedVariable;
 import ap.parser.ITerm;
+import ap.parser.ITermITE;
 import ap.parser.ITimes;
 import ap.terfor.ConstantTerm;
 import ap.terfor.conjunctions.Quantifier.ALL$;
@@ -243,6 +244,9 @@ private ITerm toTerm(final ITerm term) {
       if(term instanceof IFunApp fun) {
         return new IFunApp(fun.fun(), toTerm(fun.args()));
       }
+     if(term instanceof ITermITE ite) {
+       return new ITermITE(toFormula(ite.cond()), toTerm(ite.left()), toTerm(ite.right()));
+     }
 
       throw new IllegalArgumentException("Unhandled term: " + term);
     }

From 2a5e5d33acd32a112bdd6ccc46278ddb2158aae2 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Fri, 19 Jun 2026 14:38:59 +0200
Subject: [PATCH 37/77] fix all the code warnings

---
 .../java_smt/cmdline/CmdLineArgument.java         |  1 +
 .../debugging/DebuggingHornProverEnvironment.java | 11 -----------
 .../logging/LoggingHornProverEnvironment.java     | 10 ----------
 .../StatisticsHornProverEnvironment.java          |  3 ---
 .../SynchronizedHornProverEnvironment.java        |  8 --------
 ...chronizedHornProverEnvironmentWithContext.java | 10 ----------
 .../trace/TraceHornProverEnvironment.java         | 15 ---------------
 .../solvers/princess/EldaricaHornProver.java      |  4 ++--
 .../princess/eldarica/PrincessHornConverter.java  | 13 +++++--------
 .../java_smt/test/EldaricaHornProverTest.java     |  6 ++++++
 .../java_smt/test/horn/HornExampleTest.java       |  6 +++---
 11 files changed, 17 insertions(+), 70 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/cmdline/CmdLineArgument.java b/src/org/sosy_lab/java_smt/cmdline/CmdLineArgument.java
index a1858145a0..d8048bda2a 100644
--- a/src/org/sosy_lab/java_smt/cmdline/CmdLineArgument.java
+++ b/src/org/sosy_lab/java_smt/cmdline/CmdLineArgument.java
@@ -46,6 +46,7 @@ public int compareTo(CmdLineArgument other) {
   }
 
   @Override
+  @SuppressWarnings("PatternMatchingInstanceof")
   public boolean equals(Object o) {
     if (this == o) {
       return true;
diff --git a/src/org/sosy_lab/java_smt/delegate/debugging/DebuggingHornProverEnvironment.java b/src/org/sosy_lab/java_smt/delegate/debugging/DebuggingHornProverEnvironment.java
index ec094b154f..97f2c8354e 100644
--- a/src/org/sosy_lab/java_smt/delegate/debugging/DebuggingHornProverEnvironment.java
+++ b/src/org/sosy_lab/java_smt/delegate/debugging/DebuggingHornProverEnvironment.java
@@ -8,24 +8,13 @@
 
 package org.sosy_lab.java_smt.delegate.debugging;
 
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import java.util.Collection;
-import java.util.List;
-import org.sosy_lab.java_smt.api.BooleanFormula;
 import org.sosy_lab.java_smt.api.HornProverEnvironment;
-import org.sosy_lab.java_smt.api.InterpolatingProverEnvironment;
-import org.sosy_lab.java_smt.api.SolverException;
 
 class DebuggingHornProverEnvironment extends DebuggingBasicProverEnvironment<Void>
     implements HornProverEnvironment {
-  private final HornProverEnvironment delegate;
-  private final DebuggingAssertions debugging;
 
   DebuggingHornProverEnvironment(
       HornProverEnvironment pDelegate, DebuggingAssertions pDebugging) {
     super(pDelegate, pDebugging);
-    delegate = checkNotNull(pDelegate);
-    debugging = pDebugging;
   }
 }
diff --git a/src/org/sosy_lab/java_smt/delegate/logging/LoggingHornProverEnvironment.java b/src/org/sosy_lab/java_smt/delegate/logging/LoggingHornProverEnvironment.java
index 8ed635b05b..7733611272 100644
--- a/src/org/sosy_lab/java_smt/delegate/logging/LoggingHornProverEnvironment.java
+++ b/src/org/sosy_lab/java_smt/delegate/logging/LoggingHornProverEnvironment.java
@@ -8,24 +8,14 @@
 
 package org.sosy_lab.java_smt.delegate.logging;
 
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import java.util.Optional;
-import java.util.logging.Level;
 import org.sosy_lab.common.log.LogManager;
-import org.sosy_lab.common.rationals.Rational;
-import org.sosy_lab.java_smt.api.Formula;
 import org.sosy_lab.java_smt.api.HornProverEnvironment;
-import org.sosy_lab.java_smt.api.SolverException;
 
 /** Wrapper for a horn solver. */
 class LoggingHornProverEnvironment extends LoggingBasicProverEnvironment<Void>
     implements HornProverEnvironment {
 
-  private final HornProverEnvironment delegate;
-
   LoggingHornProverEnvironment(LogManager logger, HornProverEnvironment delegate) {
     super(delegate, logger);
-    this.delegate = checkNotNull(delegate);
   }
 }
diff --git a/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsHornProverEnvironment.java b/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsHornProverEnvironment.java
index 12641ee2d1..394a6e2781 100644
--- a/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsHornProverEnvironment.java
+++ b/src/org/sosy_lab/java_smt/delegate/statistics/StatisticsHornProverEnvironment.java
@@ -13,11 +13,8 @@
 class StatisticsHornProverEnvironment extends StatisticsBasicProverEnvironment<Void>
     implements HornProverEnvironment {
 
-  private final HornProverEnvironment delegate;
-
   StatisticsHornProverEnvironment(
       HornProverEnvironment pDelegate, SolverStatistics pStats) {
     super(pDelegate, pStats);
-    delegate = pDelegate;
   }
 }
diff --git a/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedHornProverEnvironment.java b/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedHornProverEnvironment.java
index 09c6efa162..5d1cc2258b 100644
--- a/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedHornProverEnvironment.java
+++ b/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedHornProverEnvironment.java
@@ -8,22 +8,14 @@
 
 package org.sosy_lab.java_smt.delegate.synchronize;
 
-import java.util.Collection;
-import java.util.List;
-import org.sosy_lab.java_smt.api.BooleanFormula;
 import org.sosy_lab.java_smt.api.HornProverEnvironment;
-import org.sosy_lab.java_smt.api.InterpolatingProverEnvironment;
 import org.sosy_lab.java_smt.api.SolverContext;
-import org.sosy_lab.java_smt.api.SolverException;
 
 class SynchronizedHornProverEnvironment extends SynchronizedBasicProverEnvironment<Void>
     implements HornProverEnvironment {
 
-  private final HornProverEnvironment delegate;
-
   SynchronizedHornProverEnvironment(
       HornProverEnvironment pDelegate, SolverContext pSync) {
     super(pDelegate, pSync);
-    delegate = pDelegate;
   }
 }
diff --git a/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedHornProverEnvironmentWithContext.java b/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedHornProverEnvironmentWithContext.java
index 79d90b6f48..fd6f8413df 100644
--- a/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedHornProverEnvironmentWithContext.java
+++ b/src/org/sosy_lab/java_smt/delegate/synchronize/SynchronizedHornProverEnvironmentWithContext.java
@@ -8,29 +8,19 @@
 
 package org.sosy_lab.java_smt.delegate.synchronize;
 
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import java.util.Collection;
-import java.util.List;
-import org.sosy_lab.java_smt.api.BooleanFormula;
 import org.sosy_lab.java_smt.api.FormulaManager;
 import org.sosy_lab.java_smt.api.HornProverEnvironment;
-import org.sosy_lab.java_smt.api.InterpolatingProverEnvironment;
 import org.sosy_lab.java_smt.api.SolverContext;
-import org.sosy_lab.java_smt.api.SolverException;
 
 class SynchronizedHornProverEnvironmentWithContext
     extends SynchronizedBasicProverEnvironmentWithContext<Void>
     implements HornProverEnvironment {
 
-  private final HornProverEnvironment delegate;
-
   SynchronizedHornProverEnvironmentWithContext(
       HornProverEnvironment pDelegate,
       SolverContext pSync,
       FormulaManager pManager,
       FormulaManager pOtherManager) {
     super(pDelegate, pSync, pManager, pOtherManager);
-    delegate = checkNotNull(pDelegate);
   }
 }
diff --git a/src/org/sosy_lab/java_smt/delegate/trace/TraceHornProverEnvironment.java b/src/org/sosy_lab/java_smt/delegate/trace/TraceHornProverEnvironment.java
index 28302ea209..f48bdb7ba0 100644
--- a/src/org/sosy_lab/java_smt/delegate/trace/TraceHornProverEnvironment.java
+++ b/src/org/sosy_lab/java_smt/delegate/trace/TraceHornProverEnvironment.java
@@ -10,30 +10,15 @@
 
 package org.sosy_lab.java_smt.delegate.trace;
 
-import com.google.common.base.Joiner;
-import com.google.common.collect.FluentIterable;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.List;
-import java.util.Objects;
-import org.sosy_lab.java_smt.api.BooleanFormula;
 import org.sosy_lab.java_smt.api.HornProverEnvironment;
-import org.sosy_lab.java_smt.api.InterpolatingProverEnvironment;
-import org.sosy_lab.java_smt.api.SolverException;
 
 class TraceHornProverEnvironment extends TraceBasicProverEnvironment<Void>
     implements HornProverEnvironment {
-  private final HornProverEnvironment delegate;
-  private final TraceFormulaManager mgr;
-  private final TraceLogger logger;
 
   TraceHornProverEnvironment(
       HornProverEnvironment pDelegate,
       TraceFormulaManager pFormulaManager,
       TraceLogger pLogger) {
     super(pDelegate, pFormulaManager, pLogger);
-    delegate = pDelegate;
-    mgr = pFormulaManager;
-    logger = pLogger;
   }
 }
diff --git a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
index e6bf9ca939..979f5cd074 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
@@ -38,7 +38,7 @@
 
 public class EldaricaHornProver extends PrincessAbstractProver<Void> implements
                                                                      HornProverEnvironment {
-  private final HornAPI horn;
+//  private final HornAPI horn;
   private final ArrayList<Clause> clauses = new ArrayList<>();
   private final PrincessHornConverter converter = new PrincessHornConverter();
 
@@ -49,7 +49,7 @@ public EldaricaHornProver(
       ShutdownNotifier pShutdownNotifier,
       Set<ProverOptions> pOptions) {
     super(pMgr, creator, pApi, pShutdownNotifier, pOptions);
-    this.horn = new HornAPI(new HornAPI.CEGAROptions()); // TODO: options
+   // this.horn = new HornAPI(new HornAPI.CEGAROptions()); // TODO: options
   }
 
   private void addConstraint1(BooleanFormula constraint) {
diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
index d36c798b11..4edef57fd0 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -45,6 +45,7 @@
 import scala.collection.immutable.Seq;
 import scala.jdk.javaapi.CollectionConverters;
 
+@SuppressWarnings({"unchecked", "PatternMatchingInstanceof"})
 public class PrincessHornConverter {
   private final ArrayList<Predicate> predicates = new ArrayList<>();
   private final ArrayList<IConstant> parameters = new ArrayList<>();
@@ -70,7 +71,7 @@ class ClauseContext {
 
 
     private List<IFormula> flatten(final IBinFormula input) {
-      if (input.j() == IBinJunctor.And()) {
+      if (input.j().equals(IBinJunctor.And())) {
         return flattenAnd(input);
       }
 
@@ -221,10 +222,6 @@ private IConstant toVariable(final ISortedVariable variable) {
       return constant;
     }
 
-    private ITerm toTerm(final IdealInt term) {
-      return new IIntLit(term);
-    }
-
     private ITerm toTerm(final ITerm term) {
       if (term instanceof IIntLit lit) {
         return lit;
@@ -259,7 +256,7 @@ private ITerm toConstraint(final ITerm term) {
         return toVariable(variable);
       }
       if (term instanceof IFunApp fun) {
-        return addConstraint(new IFunApp(fun.fun(), toTerm(fun.args())));
+        return new IFunApp(fun.fun(), toTerm(fun.args()));
       }
       return addConstraint(toTerm(term));
     }
@@ -276,7 +273,7 @@ private Seq<ITerm> toTerm(final Seq<ITerm> terms) {
 
     @Nullable
     private IAtom toAtom(final IIntFormula formula) {
-      if (formula.t() instanceof IFunApp t && formula.rel() == IIntRelation.EqZero()) {
+      if (formula.t() instanceof IFunApp t && formula.rel().equals(IIntRelation.EqZero())) {
         if (t.fun() instanceof MonoSortedIFunction fun) {
           return new IAtom(toPredicate(fun), toTerm(t.args()));
         }
@@ -298,7 +295,7 @@ private Clause toClause(final ISortedQuantified input) {
     }
 
     private Clause toClause(final IBinFormula input) {
-      if (input.j() != IBinJunctor.Or()) {
+      if (!input.j().equals(IBinJunctor.Or())) {
         throw new IllegalArgumentException("Illegal horn clause: " + input);
       }
 
diff --git a/src/org/sosy_lab/java_smt/test/EldaricaHornProverTest.java b/src/org/sosy_lab/java_smt/test/EldaricaHornProverTest.java
index 79621e926f..d5f7ed9d08 100644
--- a/src/org/sosy_lab/java_smt/test/EldaricaHornProverTest.java
+++ b/src/org/sosy_lab/java_smt/test/EldaricaHornProverTest.java
@@ -30,6 +30,7 @@
 import ap.types.MonoSortedIFunction;
 import ap.types.Sort;
 import ap.types.Sort.Integer$;
+import com.google.j2objc.annotations.Property.Suppress;
 import java.util.Arrays;
 import org.junit.Test;
 import org.sosy_lab.java_smt.solvers.princess.eldarica.PrincessHornConverter;
@@ -40,14 +41,19 @@
 
 public class EldaricaHornProverTest {
 
+  @SuppressWarnings("unchecked")
   private IAtom atom(String name) {
     return new IAtom(new Predicate(name, 0), (Seq<ITerm>) Seq$.MODULE$.empty());
   }
 
+  @SuppressWarnings("varargs")
+  @SafeVarargs
   private <T> Set<T> set(T... values) {
     return CollectionConverters.asScala(Arrays.asList(values)).toSet();
   }
 
+  @SuppressWarnings("varargs")
+  @SafeVarargs
   private <T> Seq<T> seq(T... values) {
     return CollectionConverters.asScala(Arrays.asList(values)).toSeq();
   }
diff --git a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
index a90942ff86..4fff2d206a 100644
--- a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
+++ b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
@@ -37,14 +37,12 @@ public void hornJavaSMT() throws Exception {
     var varA = horn.makeVariable("a");
     var varB = horn.makeVariable("b");
     var varC = horn.makeVariable("c");
-    var varD = horn.makeVariable("d");
 
     var varE = intf.makeVariable("e");
     var n1 = intf.makeNumber(1);
 
 
     var clause1 = horn.makeHornClause(varA, jList(varB, varC), intf.greaterOrEquals(varE, n1));
-    var clause11 = horn.makeHornClause(varA, jList(), intf.greaterThan(varE, n1));
     var clause2 = horn.makeHornClause(jList(varB)); // TODO: Simplify to true???
     var clause3 = horn.makeHornClause(varA, jList(varC));
     {
@@ -124,6 +122,7 @@ public void hornJavaSMTPredicate() throws Exception {
     }
   }
 
+  @SuppressWarnings("DefaultCharset")
   private HornProverEnvironment solveSmtLib2(final String file) throws Exception {
     var input =
         new String(HornExampleTest.class.getResourceAsStream("/org/sosy_lab/java_smt/test/horn/" + file +
@@ -192,7 +191,8 @@ public void smt_small_sat() throws Exception {
     assertFalse(prover.isUnsat());
   }
 
-
+  @SuppressWarnings("varargs")
+  @SafeVarargs
   private <A> java.util.List<A> jList(A... vars) {
     return java.util.Arrays.asList(vars);
   }

From ed0ee53143a12fb31de4c5b9cd4d5129513c5b75 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Fri, 19 Jun 2026 14:39:20 +0200
Subject: [PATCH 38/77] bump princess

required for eldarica
---
 doc/Example-Maven-Project/pom.xml     | 2 +-
 doc/Example-Maven-Web-Project/pom.xml | 2 +-
 lib/ivy.xml                           | 6 ++++--
 3 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/doc/Example-Maven-Project/pom.xml b/doc/Example-Maven-Project/pom.xml
index 1f550263f4..0e3085c483 100644
--- a/doc/Example-Maven-Project/pom.xml
+++ b/doc/Example-Maven-Project/pom.xml
@@ -81,7 +81,7 @@ SPDX-License-Identifier: Apache-2.0
     <mathsat.version>5.6.15</mathsat.version>
     <opensmt.version>2.9.0-gef441e1c</opensmt.version>
     <smtinterpol.version>2.5-1242-g5c50fb6d</smtinterpol.version>
-    <princess.version>2025-11-17</princess.version>
+    <princess.version>2026-05-20</princess.version>
     <ostrich.version>2.0</ostrich.version>
     <javasmt-yices.version>5.0.1-1258-gdad634a69</javasmt-yices.version>
     <yices.version>2.6.4-264-g553897f5</yices.version>
diff --git a/doc/Example-Maven-Web-Project/pom.xml b/doc/Example-Maven-Web-Project/pom.xml
index c95f4ce0a2..86ae184c44 100644
--- a/doc/Example-Maven-Web-Project/pom.xml
+++ b/doc/Example-Maven-Web-Project/pom.xml
@@ -82,7 +82,7 @@ SPDX-License-Identifier: Apache-2.0
     <mathsat.version>5.6.15</mathsat.version>
     <opensmt.version>2.9.0-gef441e1c</opensmt.version>
     <smtinterpol.version>2.5-1242-g5c50fb6d</smtinterpol.version>
-    <princess.version>2025-11-17</princess.version>
+    <princess.version>2026-05-207</princess.version>
     <ostrich.version>2.0</ostrich.version>
     <javasmt-yices.version>5.0.1-1258-gdad634a69</javasmt-yices.version>
     <yices.version>2.6.4-264-g553897f5</yices.version>
diff --git a/lib/ivy.xml b/lib/ivy.xml
index 5e16ce951a..73d652c3cc 100644
--- a/lib/ivy.xml
+++ b/lib/ivy.xml
@@ -176,10 +176,12 @@ SPDX-License-Identifier: Apache-2.0
         <dependency org="uuverifiers" name="eldarica_2.13" rev="2.2.1" conf="runtime-eldarica->master; contrib->sources"/>
 
         <!-- Princess and Ostrich for our Maven release -->
-        <dependency org="io.github.uuverifiers" name="princess_2.13" rev="2025-11-17" conf="runtime-princess-with-javacup->default; contrib->sources,javadoc"/>
+        <dependency org="io.github.uuverifiers" name="princess_2.13" rev="2025-05-20"
+                    conf="runtime-princess-with-javacup->default; contrib->sources,javadoc"/>
         <dependency org="io.github.uuverifiers" name="ostrich_2.13" rev="2.0" conf="runtime-princess-with-javacup->default; contrib->sources,javadoc"/>
         <!-- Princess and Ostrich for our Ivy release -->
-        <dependency org="io.github.uuverifiers" name="princess_2.13" rev="2025-11-17" conf="runtime-princess->default; contrib->sources,javadoc">
+        <dependency org="io.github.uuverifiers" name="princess_2.13" rev="2026-05-20"
+                    conf="runtime-princess->default; contrib->sources,javadoc">
             <!-- Exclude dependency on java-cup and replace it with java-cup-runtime, which is enough.
                We use the JAR that is published by us instead of the one from net.sf.squirrel-sql.thirdparty-non-maven
                because the latter does not provide a separate JAR for java-cup-runtime. -->

From 1d8449a31c64080c2139bae47314994dfc6e2386 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Fri, 19 Jun 2026 14:39:52 +0200
Subject: [PATCH 39/77] bump eldarica

Fixes several issues with the CHC comp and StackOverflow errors
---
 lib/ivy.xml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/lib/ivy.xml b/lib/ivy.xml
index 73d652c3cc..220be1ef72 100644
--- a/lib/ivy.xml
+++ b/lib/ivy.xml
@@ -173,7 +173,8 @@ SPDX-License-Identifier: Apache-2.0
         <dependency org="de.uni-freiburg.informatik.ultimate" name="smtinterpol" rev="2.5-1242-g5c50fb6d" conf="runtime-smtinterpol->master; contrib->sources,javadoc"/>
 
         <!-- Eldarica -->
-        <dependency org="uuverifiers" name="eldarica_2.13" rev="2.2.1" conf="runtime-eldarica->master; contrib->sources"/>
+        <dependency org="uuverifiers" name="eldarica_2.13" rev="2.3"
+                    conf="runtime-eldarica->master; contrib->sources"/>
 
         <!-- Princess and Ostrich for our Maven release -->
         <dependency org="io.github.uuverifiers" name="princess_2.13" rev="2025-05-20"

From 9c75aa6f27f9bc40705abcf12364ad3a5dea1449 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Fri, 19 Jun 2026 14:46:31 +0200
Subject: [PATCH 40/77] eldarica debug logging

---
 .../solvers/princess/EldaricaHornProver.java  | 28 ++++++++++++++-----
 1 file changed, 21 insertions(+), 7 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
index 979f5cd074..0c62b22dd1 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
@@ -10,7 +10,6 @@
 
 package org.sosy_lab.java_smt.solvers.princess;
 
-import ap.CmdlMain.NullStream$;
 import ap.api.SimpleAPI;
 import ap.parser.IAtom;
 import ap.parser.IFormula;
@@ -18,9 +17,10 @@
 import com.google.common.base.Preconditions;
 import java.util.ArrayList;
 import java.util.Set;
+import lazabs.GlobalParameters;
 import lazabs.horn.CEGARHornWrapper;
-import lazabs.horn.HornAPI;
 import lazabs.horn.Util.Dag;
+import lazabs.horn.Util.NullStream$;
 import lazabs.horn.abstractions.EmptyVerificationHints$;
 import lazabs.horn.bottomup.HornClauses.Clause;
 import lazabs.horn.preprocessor.DefaultPreprocessor;
@@ -38,10 +38,22 @@
 
 public class EldaricaHornProver extends PrincessAbstractProver<Void> implements
                                                                      HornProverEnvironment {
-//  private final HornAPI horn;
+  //  private final HornAPI horn;
   private final ArrayList<Clause> clauses = new ArrayList<>();
   private final PrincessHornConverter converter = new PrincessHornConverter();
 
+  private static final boolean DEBUG_LOGGING = "true".equals(System.getenv("ELDARICA_DEBUG"));
+
+  static {
+    if (DEBUG_LOGGING) {
+      GlobalParameters.get().setLogLevel(3);
+      GlobalParameters.get().log_$eq(true);
+    } else {
+      GlobalParameters.get().setLogLevel(0);
+      GlobalParameters.get().log_$eq(false);
+    }
+  }
+
   public EldaricaHornProver(
       PrincessFormulaManager pMgr,
       PrincessFormulaCreator creator,
@@ -49,7 +61,7 @@ public EldaricaHornProver(
       ShutdownNotifier pShutdownNotifier,
       Set<ProverOptions> pOptions) {
     super(pMgr, creator, pApi, pShutdownNotifier, pOptions);
-   // this.horn = new HornAPI(new HornAPI.CEGAROptions()); // TODO: options
+    // this.horn = new HornAPI(new HornAPI.CEGAROptions()); // TODO: options
   }
 
   private void addConstraint1(BooleanFormula constraint) {
@@ -86,10 +98,12 @@ protected Void addConstraintImpl(BooleanFormula constraint) throws InterruptedEx
   private Either<Function0<Map<Predicate, IFormula>>, Function0<Dag<IAtom>>> solve() {
     var clauses = CollectionConverters.asScala(this.clauses).toSeq();
     var preprocessor = new DefaultPreprocessor();
-    var preprocessed = preprocessor.process(clauses,EmptyVerificationHints$.MODULE$);
+    var preprocessed = preprocessor.process(clauses, EmptyVerificationHints$.MODULE$);
+
+    var stream = DEBUG_LOGGING ? System.err : NullStream$.MODULE$;
 
     var result = new CEGARHornWrapper(clauses, preprocessed._1(), preprocessed._2(),
-        preprocessed._3(), false, System.err).result();
+        preprocessed._3(), false, stream).result();
 
 
     return result;
@@ -100,7 +114,7 @@ protected boolean isUnsatImpl() throws SolverException {
     var result = solve();
 
     return result.isRight();
-   // return !this.horn.isSat(CollectionConverters.asScala(this.clauses));
+    // return !this.horn.isSat(CollectionConverters.asScala(this.clauses));
   }
 
   // TODO: Model, push/pop?.

From d975012ef6813b6aadb995a49da216d21db459dc Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Fri, 19 Jun 2026 14:49:49 +0200
Subject: [PATCH 41/77] git: ignore CPALog.txt*

Generated automatically?
---
 .gitignore                                    |  3 +++
 .../solvers/princess/EldaricaHornProver.java  | 24 +++++++++++++------
 .../java_smt/test/horn/HornExampleTest.java   |  5 ----
 3 files changed, 20 insertions(+), 12 deletions(-)

diff --git a/.gitignore b/.gitignore
index 8a1cb63763..3a5dad4373 100644
--- a/.gitignore
+++ b/.gitignore
@@ -81,3 +81,6 @@ pom.xml
 
 
 hs_err_*.log
+
+CPALog.txt
+CPALog.txt.lck
diff --git a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
index 0c62b22dd1..cd1296a88d 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
@@ -15,6 +15,7 @@
 import ap.parser.IFormula;
 import ap.terfor.preds.Predicate;
 import com.google.common.base.Preconditions;
+import java.io.PrintStream;
 import java.util.ArrayList;
 import java.util.Set;
 import lazabs.GlobalParameters;
@@ -31,6 +32,7 @@
 import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
 import org.sosy_lab.java_smt.api.SolverException;
 import org.sosy_lab.java_smt.solvers.princess.eldarica.PrincessHornConverter;
+import scala.Console$;
 import scala.Function0;
 import scala.collection.immutable.Map;
 import scala.jdk.javaapi.CollectionConverters;
@@ -96,17 +98,25 @@ protected Void addConstraintImpl(BooleanFormula constraint) throws InterruptedEx
   }
 
   private Either<Function0<Map<Predicate, IFormula>>, Function0<Dag<IAtom>>> solve() {
-    var clauses = CollectionConverters.asScala(this.clauses).toSeq();
-    var preprocessor = new DefaultPreprocessor();
-    var preprocessed = preprocessor.process(clauses, EmptyVerificationHints$.MODULE$);
+    var stream = DEBUG_LOGGING ? System.err : new PrintStream(NullStream$.MODULE$);
 
-    var stream = DEBUG_LOGGING ? System.err : NullStream$.MODULE$;
+    var err = Console$.MODULE$.err();
+    try {
+      Console$.MODULE$.setErrDirect(stream);
 
-    var result = new CEGARHornWrapper(clauses, preprocessed._1(), preprocessed._2(),
-        preprocessed._3(), false, stream).result();
+      var clauses = CollectionConverters.asScala(this.clauses).toSeq();
+      var preprocessor = new DefaultPreprocessor();
+      var preprocessed = preprocessor.process(clauses, EmptyVerificationHints$.MODULE$);
 
 
-    return result;
+      var result = new CEGARHornWrapper(clauses, preprocessed._1(), preprocessed._2(),
+          preprocessed._3(), false, stream).result();
+
+
+      return result;
+    } finally {
+      Console$.MODULE$.setErrDirect(err);
+    }
   }
 
   @Override
diff --git a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
index 4fff2d206a..a37d0f1969 100644
--- a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
+++ b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
@@ -22,11 +22,6 @@
 public class HornExampleTest {
   // TODO: Test with all solvers, not just eldarica (ParameterizedSolverBasedTest0)
 
-  // static {
-  //   GlobalParameters.get().setLogLevel(3);
-  //   GlobalParameters.get().log_$eq(true);
-  // }
-
   @Test
   public void hornJavaSMT() throws Exception {
     final var context = SolverContextFactory.createSolverContext(Solvers.ELDARICA);

From acfdb5e269d4a834bc7d1030ff2410f96fae6fd1 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Mon, 22 Jun 2026 13:46:15 +0200
Subject: [PATCH 42/77] horn converter: crash more agressively

prevents side effects
---
 .../princess/eldarica/PrincessHornConverter.java     | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
index 4edef57fd0..b8030c070b 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -144,7 +144,7 @@ private Clause toClause(final IAtom head, final IFormula rest) {
         return toClause(head, (IBinFormula) rest);
       }
 
-      throw new RuntimeException("TODO");
+      throw new RuntimeException("Unhandled clause: " + rest);
     }
 
     private IConstant addConstraint(final ITerm term) {
@@ -197,7 +197,7 @@ private IFormula toFormula(final IFormula formula) {
         return toFormula(bin);
       }
 
-      return formula;
+      throw new IllegalArgumentException("Unhandled formula: " + formula);
     }
 
     private IConstant toVariable(final ISortedVariable variable) {
@@ -288,7 +288,7 @@ private Clause toClause(final IAtom input) {
 
     private Clause toClause(final ISortedQuantified input) {
       if (input.quan() != ALL$.MODULE$) {
-        throw new IllegalArgumentException("Illegal horn clause: " + input);
+        throw new IllegalArgumentException("Invalid quantifier: " + input);
       }
 
       return toClause(input.subformula()); // TODO: Really?
@@ -296,7 +296,7 @@ private Clause toClause(final ISortedQuantified input) {
 
     private Clause toClause(final IBinFormula input) {
       if (!input.j().equals(IBinJunctor.Or())) {
-        throw new IllegalArgumentException("Illegal horn clause: " + input);
+        throw new IllegalArgumentException("Invalid formlar junctor: " + input);
       }
 
       INot not;
@@ -310,7 +310,7 @@ private Clause toClause(final IBinFormula input) {
         not = (INot) input.f2();
         other = input.f1();
       } else {
-        throw new RuntimeException("TODO");
+        throw new IllegalArgumentException("Unhandled clause: " + input);
       }
 
       IAtom head;
@@ -351,7 +351,7 @@ public Clause toClause(IFormula input) {
         return toClause(toAtom((IIntFormula) input));
       }
 
-      throw new IllegalArgumentException("Illegal horn clause: " + input);
+      throw new IllegalArgumentException("Unhandled clause: " + input);
     }
   }
 

From ae7fd427f9c826aab168cf39b64fe14f6d4d3553 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Mon, 22 Jun 2026 13:46:41 +0200
Subject: [PATCH 43/77] fix more conversion issues

---
 .../eldarica/PrincessHornConverter.java       | 42 +++++++++++++------
 1 file changed, 29 insertions(+), 13 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
index b8030c070b..3216830ced 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -10,7 +10,6 @@
 
 package org.sosy_lab.java_smt.solvers.princess.eldarica;
 
-import ap.basetypes.IdealInt;
 import ap.parser.IAtom;
 import ap.parser.IBinFormula;
 import ap.parser.IBinJunctor;
@@ -18,6 +17,7 @@
 import ap.parser.IConstant;
 import ap.parser.IEquation;
 import ap.parser.IFormula;
+import ap.parser.IFormulaITE;
 import ap.parser.IFunApp;
 import ap.parser.IIntFormula;
 import ap.parser.IIntLit;
@@ -99,6 +99,12 @@ private Clause toClause(final IAtom head, final IAtom rest) {
           this.constraint);
     }
 
+    private Clause toClause(final IAtom head, final IBoolLit rest) {
+      this.constraint = this.constraint.andSimplify(rest);
+
+      return new Clause(head, List$.MODULE$.empty(), this.constraint);
+    }
+
     private Clause toClause(final IAtom head, final IIntFormula rest) {
       var atom = toAtom(rest);
       if (atom != null) {
@@ -134,14 +140,17 @@ private Clause toClause(final IAtom head, final IBinFormula rest) {
     }
 
     private Clause toClause(final IAtom head, final IFormula rest) {
-      if (rest instanceof IAtom) {
-        return toClause(head, (IAtom) rest);
+      if (rest instanceof IAtom atom) {
+        return toClause(head, atom);
+      }
+      if (rest instanceof IIntFormula _int) {
+        return toClause(head, _int);
       }
-      if (rest instanceof IIntFormula) {
-        return toClause(head, (IIntFormula) rest);
+      if (rest instanceof IBinFormula bin) {
+        return toClause(head, bin);
       }
-      if (rest instanceof IBinFormula) {
-        return toClause(head, (IBinFormula) rest);
+      if (rest instanceof IBoolLit lit) {
+        return toClause(head, lit);
       }
 
       throw new RuntimeException("Unhandled clause: " + rest);
@@ -196,6 +205,12 @@ private IFormula toFormula(final IFormula formula) {
       if (formula instanceof INot bin) {
         return toFormula(bin);
       }
+      if (formula instanceof IBoolLit lit) {
+        return lit;
+      }
+      if (formula instanceof IFormulaITE ite) {
+        return new IFormulaITE(toFormula(ite.cond()), toFormula(ite.left()), toFormula(ite.right()));
+      }
 
       throw new IllegalArgumentException("Unhandled formula: " + formula);
     }
@@ -226,7 +241,7 @@ private ITerm toTerm(final ITerm term) {
       if (term instanceof IIntLit lit) {
         return lit;
       }
-      if(term instanceof IConstant constant) {
+      if (term instanceof IConstant constant) {
         return constant;
       }
       if (term instanceof ISortedVariable variable) {
@@ -238,12 +253,12 @@ private ITerm toTerm(final ITerm term) {
       if (term instanceof ITimes times) {
         return new ITimes(times.coeff(), toTerm(times.subterm()));
       }
-      if(term instanceof IFunApp fun) {
+      if (term instanceof IFunApp fun) {
         return new IFunApp(fun.fun(), toTerm(fun.args()));
       }
-     if(term instanceof ITermITE ite) {
-       return new ITermITE(toFormula(ite.cond()), toTerm(ite.left()), toTerm(ite.right()));
-     }
+      if (term instanceof ITermITE ite) {
+        return new ITermITE(toFormula(ite.cond()), toTerm(ite.left()), toTerm(ite.right()));
+      }
 
       throw new IllegalArgumentException("Unhandled term: " + term);
     }
@@ -291,7 +306,8 @@ private Clause toClause(final ISortedQuantified input) {
         throw new IllegalArgumentException("Invalid quantifier: " + input);
       }
 
-      return toClause(input.subformula()); // TODO: Really?
+      // Eldarica seems to always use for all quantifiers, so it is just removed
+      return toClause(input.subformula());
     }
 
     private Clause toClause(final IBinFormula input) {

From f940d0f6b8c7ef65eab8adb4e1c4ef3a5db3606e Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Mon, 22 Jun 2026 15:17:51 +0200
Subject: [PATCH 44/77] smt2 tokenizer: allow declare-datatypes

Use for custom sorts
---
 src/org/sosy_lab/java_smt/basicimpl/Tokenizer.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/org/sosy_lab/java_smt/basicimpl/Tokenizer.java b/src/org/sosy_lab/java_smt/basicimpl/Tokenizer.java
index fe99a395bd..e528806363 100644
--- a/src/org/sosy_lab/java_smt/basicimpl/Tokenizer.java
+++ b/src/org/sosy_lab/java_smt/basicimpl/Tokenizer.java
@@ -184,7 +184,7 @@ public static boolean isSetInfoToken(String token) {
    * <p>Use {@link #tokenize(String)} to turn an SMT-LIB2 script into a string of input tokens.
    */
   public static boolean isDeclarationToken(String token) {
-    return matchesOneOf(token, "declare-const", "declare-fun");
+    return matchesOneOf(token, "declare-const", "declare-fun", "declare-datatypes");
   }
 
   /**

From 9eba9ee0ea0b92ee3efeb5732b56e5bf40797121 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Mon, 22 Jun 2026 15:18:17 +0200
Subject: [PATCH 45/77] princess: map custom sorts to types

---
 .../solvers/princess/PrincessEnvironment.java | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/PrincessEnvironment.java b/src/org/sosy_lab/java_smt/solvers/princess/PrincessEnvironment.java
index 6da08414e6..d57f82103d 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/PrincessEnvironment.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/PrincessEnvironment.java
@@ -37,6 +37,7 @@
 import ap.theories.bitvectors.ModuloArithmetic;
 import ap.theories.rationals.Rationals$;
 import ap.theories.strings.StringTheory;
+import ap.types.ProxySort;
 import ap.types.Sort;
 import ap.types.Sort$;
 import ap.types.Sort.MultipleValueBool$;
@@ -606,6 +607,15 @@ private static FormulaType<?> getFormulaTypeFromSort(final Sort sort) {
           getFormulaTypeFromSort(elementSort));
     } else if (sort instanceof MultipleValueBool$) {
       return FormulaType.BooleanType;
+    } else if (sort instanceof ADTProxySort adt) {
+      var type = getProxyName(adt);
+      if ("int".equals(type)) {
+        return FormulaType.IntegerType;
+      }
+      if (type.startsWith("int[")) {
+        return FormulaType.getArrayType(FormulaType.IntegerType, FormulaType.IntegerType);
+      }
+      throw new IllegalArgumentException("Can not get formula type " + type);
     } else {
       // Check if it's a bitvector sort
       scala.Option<Object> bitWidth = getBitWidth(sort);
@@ -767,4 +777,15 @@ IExpression simplify(IExpression f) {
     }
     return PartialEvaluator.apply(f);
   }
+
+  private static String getProxyName(final ADTProxySort sort) {
+    try {
+      var field = ProxySort.class.getDeclaredField("name");
+      field.setAccessible(true);
+
+      return (String) field.get(sort);
+    } catch (Exception error) {
+      throw new RuntimeException(error);
+    }
+  }
 }

From b2b0d1b6a56b74e0978cc20bf8551631300160fd Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Tue, 23 Jun 2026 14:44:20 +0200
Subject: [PATCH 46/77] more conversion fixes

---
 .../eldarica/PrincessHornConverter.java       | 56 ++++++++++++++-----
 1 file changed, 43 insertions(+), 13 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
index 3216830ced..06b6a35fc3 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -94,15 +94,27 @@ private List<IFormula> flatten(final IFormula input) {
       return List.of(toFormula(input));
     }
 
+
     private Clause toClause(final IAtom head, final IAtom rest) {
-      return new Clause(head, CollectionConverters.asScala(List.of(rest)).toList(),
+      return new Clause(head, CollectionConverters.asScala(List.of(toFormula(rest))).toList(),
           this.constraint);
     }
 
     private Clause toClause(final IAtom head, final IBoolLit rest) {
       this.constraint = this.constraint.andSimplify(rest);
+      return toClause(head);
+    }
 
-      return new Clause(head, List$.MODULE$.empty(), this.constraint);
+    private Clause toClause(final IAtom head, final IEquation rest) {
+      this.constraint = this.constraint.andSimplify(toFormula(rest));
+
+      return toClause(head);
+    }
+
+    private Clause toClause(final IAtom head, final INot rest) {
+      this.constraint = this.constraint.andSimplify(toFormula(rest));
+
+      return toClause(head);
     }
 
     private Clause toClause(final IAtom head, final IIntFormula rest) {
@@ -113,7 +125,7 @@ private Clause toClause(final IAtom head, final IIntFormula rest) {
       }
       // TODO: Is that duplicating the constraint?
       this.constraint = this.constraint.andSimplify(toFormula(rest));
-      return new Clause(head, List$.MODULE$.empty(), this.constraint);
+      return toClause(head);
     }
 
     private Clause toClause(final IAtom head, final IBinFormula rest) {
@@ -152,7 +164,12 @@ private Clause toClause(final IAtom head, final IFormula rest) {
       if (rest instanceof IBoolLit lit) {
         return toClause(head, lit);
       }
-
+      if (rest instanceof IEquation eq) {
+        return toClause(head, eq);
+      }
+      if (rest instanceof INot not) {
+        return toClause(head, not);
+      }
       throw new RuntimeException("Unhandled clause: " + rest);
     }
 
@@ -209,7 +226,8 @@ private IFormula toFormula(final IFormula formula) {
         return lit;
       }
       if (formula instanceof IFormulaITE ite) {
-        return new IFormulaITE(toFormula(ite.cond()), toFormula(ite.left()), toFormula(ite.right()));
+        return new IFormulaITE(toFormula(ite.cond()), toFormula(ite.left()),
+            toFormula(ite.right()));
       }
 
       throw new IllegalArgumentException("Unhandled formula: " + formula);
@@ -297,8 +315,8 @@ private IAtom toAtom(final IIntFormula formula) {
       return null;
     }
 
-    private Clause toClause(final IAtom input) {
-      return new Clause(input, List$.MODULE$.empty(), this.constraint);
+    private Clause toClause(final IAtom head) {
+      return new Clause(head, List$.MODULE$.empty(), this.constraint);
     }
 
     private Clause toClause(final ISortedQuantified input) {
@@ -310,6 +328,20 @@ private Clause toClause(final ISortedQuantified input) {
       return toClause(input.subformula());
     }
 
+    private IFormula simplify(IFormula formula) {
+      if (formula instanceof INot not) {
+        return simplify(not);
+      }
+      return formula;
+    }
+
+    private IFormula simplify(INot not) {
+      if (not.subformula() instanceof INot sub) {
+        return simplify(sub);
+      }
+      return not;
+    }
+
     private Clause toClause(final IBinFormula input) {
       if (!input.j().equals(IBinJunctor.Or())) {
         throw new IllegalArgumentException("Invalid formlar junctor: " + input);
@@ -336,19 +368,17 @@ private Clause toClause(final IBinFormula input) {
       } else if (other instanceof IIntFormula) {
         head = toAtom((IIntFormula) other);
         if (head == null) {
-          throw new RuntimeException("TODO");
+          throw new RuntimeException("No head found: " + input);
         }
       } else {
         head = new IAtom(HornClauses.FALSE(), (Seq<ITerm>) Seq$.MODULE$.empty());
-        this.constraint = this.constraint.andSimplify(toFormula(other).notSimplify());
+        this.constraint = this.constraint.andSimplify(simplify(toFormula(other).notSimplify()));
 
-        // TODO: (expected) Clause(FALSE,List(mc(P1, P0)),!(!((101 + -1 * P1) >= 0) | (P0 = 92)))
-        // TODO: (actual  ) Clause(FALSE,List(mc(P1, P0)),(((101 + -1 * P1) >= 0) & !(P0 = 91)))
-        return toClause(head, not.subformula());
+        return toClause(head, simplify(not.subformula()));
       }
 
 
-      return toClause(head, not.subformula());
+      return toClause(head, simplify(not.subformula()));
     }
 
     public Clause toClause(IFormula input) {

From 2b8339991fb610997042d6352ae46a0d541ec9fd Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Wed, 24 Jun 2026 16:13:39 +0200
Subject: [PATCH 47/77] horn converter: fix if then else

Not supported like that by eldarica
---
 .../eldarica/PrincessHornConverter.java       | 45 ++++++++++++++++---
 1 file changed, 40 insertions(+), 5 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
index 06b6a35fc3..030d0ba2c6 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -173,11 +173,15 @@ private Clause toClause(final IAtom head, final IFormula rest) {
       throw new RuntimeException("Unhandled clause: " + rest);
     }
 
+    private IConstant createVariable() {
+      return new IConstant(new ConstantTerm("T" + ++variables));
+    }
+
     private IConstant addConstraint(final ITerm term) {
       if (term instanceof IConstant) {
         return (IConstant) term;
       }
-      var variable = new IConstant(new ConstantTerm("T" + ++variables));
+      var variable = createVariable();
       var constraint = new IEquation(variable, term);
 
       this.constraint = this.constraint.andSimplify(constraint);
@@ -189,7 +193,7 @@ private IAtom toFormula(final IAtom atom) {
       return new IAtom(atom.pred(), toTerm(atom.args()));
     }
 
-    private IIntFormula toFormula(final IIntFormula i) {
+    private IFormula toFormula(final IIntFormula i) {
       return new IIntFormula(i.rel(), toTerm(i.t()));
     }
 
@@ -206,6 +210,19 @@ private IFormula toFormula(final INot not) {
       return toFormula(not.subformula()).notSimplify();
     }
 
+    private IFormula toFormula(final IFormulaITE ite) {
+      //return new IFormulaITE(toFormula(ite.cond()), toFormula(ite.left()),
+      //    toFormula(ite.right()));
+
+      var condition = toFormula(ite.cond());
+
+      var a = new IBinFormula(IBinJunctor.And(), condition.notSimplify(), toFormula(ite.left()));
+      var b = new IBinFormula(IBinJunctor.And(), condition, toFormula(ite.right()));
+
+
+      return a.orSimplify(b);
+    }
+
     private IFormula toFormula(final IFormula formula) {
       if (formula instanceof IAtom atom) {
         return toFormula(atom);
@@ -226,8 +243,7 @@ private IFormula toFormula(final IFormula formula) {
         return lit;
       }
       if (formula instanceof IFormulaITE ite) {
-        return new IFormulaITE(toFormula(ite.cond()), toFormula(ite.left()),
-            toFormula(ite.right()));
+        return toFormula(ite);
       }
 
       throw new IllegalArgumentException("Unhandled formula: " + formula);
@@ -255,6 +271,25 @@ private IConstant toVariable(final ISortedVariable variable) {
       return constant;
     }
 
+    private ITerm toTerm(final ITermITE ite) {
+      // return new ITermITE(toFormula(ite.cond()), toTerm(ite.left()), toTerm(ite.right()));
+      var variable = createVariable();
+
+      var condition = toFormula(ite.cond());
+
+      var left = new IEquation(variable, toTerm(ite.left()));
+      var right = new IEquation(variable, toTerm(ite.right()));
+
+
+      var a = new IBinFormula(IBinJunctor.And(), condition.notSimplify(), left);
+      var b = new IBinFormula(IBinJunctor.And(), condition, right);
+
+
+      this.constraint = this.constraint.andSimplify(a.orSimplify(b));
+
+      return variable;
+    }
+
     private ITerm toTerm(final ITerm term) {
       if (term instanceof IIntLit lit) {
         return lit;
@@ -275,7 +310,7 @@ private ITerm toTerm(final ITerm term) {
         return new IFunApp(fun.fun(), toTerm(fun.args()));
       }
       if (term instanceof ITermITE ite) {
-        return new ITermITE(toFormula(ite.cond()), toTerm(ite.left()), toTerm(ite.right()));
+        return toTerm(ite);
       }
 
       throw new IllegalArgumentException("Unhandled term: " + term);

From 5f034874f48fed852f4e61afe0c4a739224151b0 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Fri, 26 Jun 2026 00:13:15 +0200
Subject: [PATCH 48/77] fix double simplification

---
 .../solvers/princess/eldarica/PrincessHornConverter.java        | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
index 030d0ba2c6..7d1f81006d 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -372,7 +372,7 @@ private IFormula simplify(IFormula formula) {
 
     private IFormula simplify(INot not) {
       if (not.subformula() instanceof INot sub) {
-        return simplify(sub);
+        return simplify(sub.subformula());
       }
       return not;
     }

From 67e58d51e89f1e0f308f8cb810bb569053ecac9c Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Fri, 26 Jun 2026 00:32:09 +0200
Subject: [PATCH 49/77] fix ite conversion

---
 .../solvers/princess/eldarica/PrincessHornConverter.java  | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
index 7d1f81006d..3e6f98fb57 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -216,8 +216,8 @@ private IFormula toFormula(final IFormulaITE ite) {
 
       var condition = toFormula(ite.cond());
 
-      var a = new IBinFormula(IBinJunctor.And(), condition.notSimplify(), toFormula(ite.left()));
-      var b = new IBinFormula(IBinJunctor.And(), condition, toFormula(ite.right()));
+      var a = new IBinFormula(IBinJunctor.And(), condition, toFormula(ite.left()));
+      var b = new IBinFormula(IBinJunctor.And(), condition.notSimplify(), toFormula(ite.right()));
 
 
       return a.orSimplify(b);
@@ -281,8 +281,8 @@ private ITerm toTerm(final ITermITE ite) {
       var right = new IEquation(variable, toTerm(ite.right()));
 
 
-      var a = new IBinFormula(IBinJunctor.And(), condition.notSimplify(), left);
-      var b = new IBinFormula(IBinJunctor.And(), condition, right);
+      var a = new IBinFormula(IBinJunctor.And(), condition, left);
+      var b = new IBinFormula(IBinJunctor.And(), condition.notSimplify(), right);
 
 
       this.constraint = this.constraint.andSimplify(a.orSimplify(b));

From 967bfd4cad65f7b32ef8056b9e51d811ba655dcf Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Mon, 29 Jun 2026 14:00:13 +0200
Subject: [PATCH 50/77] various horn conversion  fixes

---
 .../eldarica/PrincessHornConverter.java       | 103 +++++++++++++-----
 1 file changed, 77 insertions(+), 26 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
index 3e6f98fb57..8d989994c9 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -33,6 +33,7 @@
 import ap.terfor.conjunctions.Quantifier.ALL$;
 import ap.terfor.preds.Predicate;
 import ap.types.MonoSortedIFunction;
+import ap.types.MonoSortedPredicate;
 import ap.types.Sort.Integer$;
 import ap.types.SortedConstantTerm;
 import java.util.ArrayList;
@@ -48,25 +49,29 @@
 @SuppressWarnings({"unchecked", "PatternMatchingInstanceof"})
 public class PrincessHornConverter {
   private final ArrayList<Predicate> predicates = new ArrayList<>();
-  private final ArrayList<IConstant> parameters = new ArrayList<>();
   private int variables = 0;
 
   private Predicate toPredicate(final MonoSortedIFunction function) {
-    // Predicate does not implement hashCode nor equals, this deduplicates the objects. Not 100%
-    // sure if that is needed
+    // Predicate does not implement hashCode nor equals, this deduplicates the objects.
     for (Predicate predicate : this.predicates) {
       if (!predicate.name().equals(function.name()) || predicate.arity() != function.arity()) {
         continue;
       }
       return predicate;
     }
-    Predicate predicate = new Predicate(function.name(), function.arity());
+    Predicate predicate;
+    if (function.argSorts().isEmpty()) {
+      predicate = new Predicate(function.name(), function.arity());
+    } else {
+      predicate = new MonoSortedPredicate(function.name(), function.argSorts());
+    }
     this.predicates.add(predicate);
 
     return predicate;
   }
 
   class ClauseContext {
+    private final ArrayList<IConstant> parameters = new ArrayList<>();
     private IFormula constraint = new IBoolLit(true);
 
 
@@ -96,8 +101,8 @@ private List<IFormula> flatten(final IFormula input) {
 
 
     private Clause toClause(final IAtom head, final IAtom rest) {
-      return new Clause(head, CollectionConverters.asScala(List.of(toFormula(rest))).toList(),
-          this.constraint);
+      var body = CollectionConverters.asScala(List.of(toFormula(rest))).toList();
+      return new Clause(head, body, this.constraint);
     }
 
     private Clause toClause(final IAtom head, final IBoolLit rest) {
@@ -123,7 +128,6 @@ private Clause toClause(final IAtom head, final IIntFormula rest) {
         return new Clause(head, CollectionConverters.asScala(List.of(atom)).toList(),
             this.constraint);
       }
-      // TODO: Is that duplicating the constraint?
       this.constraint = this.constraint.andSimplify(toFormula(rest));
       return toClause(head);
     }
@@ -182,7 +186,7 @@ private IConstant addConstraint(final ITerm term) {
         return (IConstant) term;
       }
       var variable = createVariable();
-      var constraint = new IEquation(variable, term);
+      var constraint = new IEquation(variable, toTerm(term));
 
       this.constraint = this.constraint.andSimplify(constraint);
 
@@ -194,16 +198,54 @@ private IAtom toFormula(final IAtom atom) {
     }
 
     private IFormula toFormula(final IIntFormula i) {
+      if (i.rel().equals(IIntRelation.EqZero()) && i.t() instanceof ITermITE ite) {
+        if (ite.left() instanceof IIntLit lit && lit.value().isZero()) {
+          return toFormula(ite.cond());
+        }
+        if (ite.right() instanceof IIntLit lit && lit.value().isZero()) {
+          return toFormula(ite.cond().notSimplify());
+        }
+      }
+      if (i.t() instanceof ITermITE) {
+        throw new RuntimeException("ITE (TODO): " + i.t());
+      }
       return new IIntFormula(i.rel(), toTerm(i.t()));
     }
 
-    private IEquation toFormula(final IEquation equation) {
+    private IFormula toFormula(ITerm value, ITermITE ite) {
+      value = toTerm(value);
+
+      var condition = toFormula(ite.cond());
+
+      var a = condition.andSimplify(new IEquation(value, toTerm(ite.left())));
+      var b = condition.notSimplify().andSimplify(new IEquation(value, toTerm(ite.right())));
+
+      return a.orSimplify(b);
+    }
+
+    private IFormula toFormula(final IEquation equation) {
+      if (equation.left() instanceof ITermITE ite) {
+        return toFormula(equation.right(), ite);
+      }
+      if (equation.right() instanceof ITermITE ite) {
+        return toFormula(equation.left(), ite);
+      }
       return new IEquation(toTerm(equation.left()), toTerm(equation.right()));
     }
 
-    private IBinFormula toFormula(final IBinFormula bin) {
-      return new IBinFormula(bin.j(), toFormula(bin.f1()),
-          toFormula(bin.f2()));
+    private IFormula toFormula(final IBinFormula bin) {
+      var f1 = toFormula(bin.f1());
+      var f2 = toFormula(bin.f2());
+      if (bin.j().equals(IBinJunctor.Eqv())) {
+        var a = f1.andSimplify(f2);
+        var b = f1.notSimplify().andSimplify(f2.notSimplify());
+
+        return a.orSimplify(b);
+      }
+      if (bin.j().equals(IBinJunctor.Or())) {
+        return (f1.notSimplify().andSimplify(f2.notSimplify())).notSimplify();
+      }
+      return new IBinFormula(bin.j(), f1, f2);
     }
 
     private IFormula toFormula(final INot not) {
@@ -211,13 +253,10 @@ private IFormula toFormula(final INot not) {
     }
 
     private IFormula toFormula(final IFormulaITE ite) {
-      //return new IFormulaITE(toFormula(ite.cond()), toFormula(ite.left()),
-      //    toFormula(ite.right()));
-
       var condition = toFormula(ite.cond());
 
-      var a = new IBinFormula(IBinJunctor.And(), condition, toFormula(ite.left()));
-      var b = new IBinFormula(IBinJunctor.And(), condition.notSimplify(), toFormula(ite.right()));
+      var a = condition.andSimplify(toFormula(ite.left()));
+      var b = condition.notSimplify().andSimplify(toFormula(ite.right()));
 
 
       return a.orSimplify(b);
@@ -272,17 +311,15 @@ private IConstant toVariable(final ISortedVariable variable) {
     }
 
     private ITerm toTerm(final ITermITE ite) {
-      // return new ITermITE(toFormula(ite.cond()), toTerm(ite.left()), toTerm(ite.right()));
-      var variable = createVariable();
-
       var condition = toFormula(ite.cond());
 
+      var variable = createVariable();
       var left = new IEquation(variable, toTerm(ite.left()));
       var right = new IEquation(variable, toTerm(ite.right()));
 
 
-      var a = new IBinFormula(IBinJunctor.And(), condition, left);
-      var b = new IBinFormula(IBinJunctor.And(), condition.notSimplify(), right);
+      var a = condition.andSimplify(left);
+      var b = condition.notSimplify().andSimplify(right);
 
 
       this.constraint = this.constraint.andSimplify(a.orSimplify(b));
@@ -317,6 +354,9 @@ private ITerm toTerm(final ITerm term) {
     }
 
     private ITerm toConstraint(final ITerm term) {
+      if (term instanceof IConstant constant) {
+        return constant;
+      }
       if (term instanceof IIntLit lit) {
         return lit;
       }
@@ -326,6 +366,12 @@ private ITerm toConstraint(final ITerm term) {
       if (term instanceof IFunApp fun) {
         return new IFunApp(fun.fun(), toTerm(fun.args()));
       }
+    //  if(term instanceof IPlus plus) {
+    //    return new IPlus(toTerm(plus.t1()), toTerm(plus.t2()));
+    //  }
+    //  if(term instanceof ITimes times) {
+    //    return new ITimes(times.coeff(), toTerm(times.subterm()));
+    //  }
       return addConstraint(toTerm(term));
     }
 
@@ -351,6 +397,7 @@ private IAtom toAtom(final IIntFormula formula) {
     }
 
     private Clause toClause(final IAtom head) {
+      assert head != null;
       return new Clause(head, List$.MODULE$.empty(), this.constraint);
     }
 
@@ -379,7 +426,7 @@ private IFormula simplify(INot not) {
 
     private Clause toClause(final IBinFormula input) {
       if (!input.j().equals(IBinJunctor.Or())) {
-        throw new IllegalArgumentException("Invalid formlar junctor: " + input);
+        throw new IllegalArgumentException("Invalid formula junctor: " + input);
       }
 
       INot not;
@@ -412,8 +459,14 @@ private Clause toClause(final IBinFormula input) {
         return toClause(head, simplify(not.subformula()));
       }
 
+      var subformula = simplify(not.subformula());
+      if (subformula instanceof IAtom atom) {
+        this.constraint = this.constraint.andSimplify(toFormula(atom).notSimplify());
+        return toClause(head);
+      }
+
 
-      return toClause(head, simplify(not.subformula()));
+      return toClause(head, subformula);
     }
 
     public Clause toClause(IFormula input) {
@@ -424,8 +477,6 @@ public Clause toClause(IFormula input) {
         return toClause((IAtom) input);
       }
       if (input instanceof IBinFormula) {
-        // (!(((((((((_0 = _8) & (_1 = _9)) & (_2 = _10)) & (_3 = _11)) & (_4 = _12)) & (_5 = _13)) & (_6 = _14)) & (_7 = _15)) & true) | (h1(_15, _14, _13, _12, _11, _10, _9, _8, _7, _6, _5, _4, _3, _2, _1, _0) = 0))
-        // Clause(h1(P15, P14, P13, P12, P11, P10, P9, P8, P7, P6, P5, P4, P3, P2, P1, P0),List(),((((((((P0 = P8) & (P1 = P9)) & (P2 = P10)) & (P3 = P11)) & (P4 = P12)) & (P5 = P13)) & (P6 = P14)) & (P7 = P15)))
         return toClause((IBinFormula) input);
       }
       if (input instanceof IIntFormula) {

From 64d8c65480c54eff8bc321527a779b4760f2ea73 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Mon, 29 Jun 2026 14:08:04 +0200
Subject: [PATCH 51/77] eldarica horn converter: don't create temporary
 variables

they might get optimized out with `andSimplify` and produce wrong results.
---
 .../eldarica/PrincessHornConverter.java       | 60 +------------------
 1 file changed, 2 insertions(+), 58 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
index 8d989994c9..42f6e62297 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -49,7 +49,6 @@
 @SuppressWarnings({"unchecked", "PatternMatchingInstanceof"})
 public class PrincessHornConverter {
   private final ArrayList<Predicate> predicates = new ArrayList<>();
-  private int variables = 0;
 
   private Predicate toPredicate(final MonoSortedIFunction function) {
     // Predicate does not implement hashCode nor equals, this deduplicates the objects.
@@ -177,22 +176,6 @@ private Clause toClause(final IAtom head, final IFormula rest) {
       throw new RuntimeException("Unhandled clause: " + rest);
     }
 
-    private IConstant createVariable() {
-      return new IConstant(new ConstantTerm("T" + ++variables));
-    }
-
-    private IConstant addConstraint(final ITerm term) {
-      if (term instanceof IConstant) {
-        return (IConstant) term;
-      }
-      var variable = createVariable();
-      var constraint = new IEquation(variable, toTerm(term));
-
-      this.constraint = this.constraint.andSimplify(constraint);
-
-      return variable;
-    }
-
     private IAtom toFormula(final IAtom atom) {
       return new IAtom(atom.pred(), toTerm(atom.args()));
     }
@@ -310,23 +293,6 @@ private IConstant toVariable(final ISortedVariable variable) {
       return constant;
     }
 
-    private ITerm toTerm(final ITermITE ite) {
-      var condition = toFormula(ite.cond());
-
-      var variable = createVariable();
-      var left = new IEquation(variable, toTerm(ite.left()));
-      var right = new IEquation(variable, toTerm(ite.right()));
-
-
-      var a = condition.andSimplify(left);
-      var b = condition.notSimplify().andSimplify(right);
-
-
-      this.constraint = this.constraint.andSimplify(a.orSimplify(b));
-
-      return variable;
-    }
-
     private ITerm toTerm(final ITerm term) {
       if (term instanceof IIntLit lit) {
         return lit;
@@ -347,39 +313,17 @@ private ITerm toTerm(final ITerm term) {
         return new IFunApp(fun.fun(), toTerm(fun.args()));
       }
       if (term instanceof ITermITE ite) {
-        return toTerm(ite);
+        throw new IllegalArgumentException("Eldarica does not support ITE terms: " + ite);
       }
 
       throw new IllegalArgumentException("Unhandled term: " + term);
     }
 
-    private ITerm toConstraint(final ITerm term) {
-      if (term instanceof IConstant constant) {
-        return constant;
-      }
-      if (term instanceof IIntLit lit) {
-        return lit;
-      }
-      if (term instanceof ISortedVariable variable) {
-        return toVariable(variable);
-      }
-      if (term instanceof IFunApp fun) {
-        return new IFunApp(fun.fun(), toTerm(fun.args()));
-      }
-    //  if(term instanceof IPlus plus) {
-    //    return new IPlus(toTerm(plus.t1()), toTerm(plus.t2()));
-    //  }
-    //  if(term instanceof ITimes times) {
-    //    return new ITimes(times.coeff(), toTerm(times.subterm()));
-    //  }
-      return addConstraint(toTerm(term));
-    }
-
     private Seq<ITerm> toTerm(final Seq<ITerm> terms) {
       final var output = new ArrayList<ITerm>();
 
       for (ITerm term : CollectionConverters.asJava(terms)) {
-        output.add(toConstraint(term));
+        output.add(toTerm(term));
       }
 
       return CollectionConverters.asScala(output).toSeq();

From 7141871713b9712f74dd52e3d530c73814c94383 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Mon, 29 Jun 2026 14:08:30 +0200
Subject: [PATCH 52/77] eldarica: horn converter: don't visit twice

---
 .../princess/eldarica/PrincessHornConverter.java   | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
index 42f6e62297..baa87b3362 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -122,7 +122,7 @@ private Clause toClause(final IAtom head, final INot rest) {
     }
 
     private Clause toClause(final IAtom head, final IIntFormula rest) {
-      var atom = toAtom(rest);
+      var atom = toPredicateAtom(rest);
       if (atom != null) {
         return new Clause(head, CollectionConverters.asScala(List.of(atom)).toList(),
             this.constraint);
@@ -136,18 +136,18 @@ private Clause toClause(final IAtom head, final IBinFormula rest) {
 
       for (IFormula and : flatten(rest)) {
         if (and instanceof IAtom atom && atom.args().isEmpty()) {
-          body.add(new IAtom(atom.pred(), toTerm(atom.args())));
+          body.add(new IAtom(atom.pred(), atom.args()));
           continue;
         }
         if (and instanceof IIntFormula) {
-          var atom = toAtom((IIntFormula) and);
+          var atom = toPredicateAtom((IIntFormula) and);
           if (atom != null) {
             body.add(atom);
             continue;
           }
         }
 
-        constraint = constraint.andSimplify(toFormula(and));
+        constraint = constraint.andSimplify(and);
       }
 
 
@@ -330,7 +330,7 @@ private Seq<ITerm> toTerm(final Seq<ITerm> terms) {
     }
 
     @Nullable
-    private IAtom toAtom(final IIntFormula formula) {
+    private IAtom toPredicateAtom(final IIntFormula formula) {
       if (formula.t() instanceof IFunApp t && formula.rel().equals(IIntRelation.EqZero())) {
         if (t.fun() instanceof MonoSortedIFunction fun) {
           return new IAtom(toPredicate(fun), toTerm(t.args()));
@@ -392,7 +392,7 @@ private Clause toClause(final IBinFormula input) {
       if (other instanceof IAtom atom) {
         head = toFormula(atom);
       } else if (other instanceof IIntFormula) {
-        head = toAtom((IIntFormula) other);
+        head = toPredicateAtom((IIntFormula) other);
         if (head == null) {
           throw new RuntimeException("No head found: " + input);
         }
@@ -424,7 +424,7 @@ public Clause toClause(IFormula input) {
         return toClause((IBinFormula) input);
       }
       if (input instanceof IIntFormula) {
-        return toClause(toAtom((IIntFormula) input));
+        return toClause(toPredicateAtom((IIntFormula) input));
       }
 
       throw new IllegalArgumentException("Unhandled clause: " + input);

From 1454c3e35f0ff6cb6742082be7b9e15700b540bc Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Mon, 29 Jun 2026 14:15:42 +0200
Subject: [PATCH 53/77] eldarica horn: add all the chc comp test files

---
 .../java_smt/test/horn/38.c_000.license       |   1 +
 .../sosy_lab/java_smt/test/horn/38.c_000.smt2 | 324 ++++++++++++++++++
 .../java_smt/test/horn/HornExampleTest.java   |  33 +-
 .../O0_fibo_10_false-unreach-call_000.license |   1 +
 .../O0_fibo_10_false-unreach-call_000.smt2    | 143 ++++++++
 ...paper_examples-points-compress_000.license |   1 +
 ...ss-paper_examples-points-compress_000.smt2 |  77 +++++
 .../test/horn/two_counters_e3_325_000.license |   1 +
 .../test/horn/two_counters_e3_325_000.smt2    |  71 ++++
 9 files changed, 650 insertions(+), 2 deletions(-)
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/38.c_000.license
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/38.c_000.smt2
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/O0_fibo_10_false-unreach-call_000.license
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/O0_fibo_10_false-unreach-call_000.smt2
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/prusti-3-pass-paper_examples-points-compress_000.license
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/prusti-3-pass-paper_examples-points-compress_000.smt2
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/two_counters_e3_325_000.license
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/two_counters_e3_325_000.smt2

diff --git a/src/org/sosy_lab/java_smt/test/horn/38.c_000.license b/src/org/sosy_lab/java_smt/test/horn/38.c_000.license
new file mode 100644
index 0000000000..1abba28dd5
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/38.c_000.license
@@ -0,0 +1 @@
+SPDX-License-Identifier: Apache-2.0
diff --git a/src/org/sosy_lab/java_smt/test/horn/38.c_000.smt2 b/src/org/sosy_lab/java_smt/test/horn/38.c_000.smt2
new file mode 100644
index 0000000000..c374654b2a
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/38.c_000.smt2
@@ -0,0 +1,324 @@
+(set-logic HORN)
+
+
+(declare-fun |h4| ( Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h19| ( Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h15| ( Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h14| ( Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h24| ( Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h6| ( Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h2| ( Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h18| ( Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |CHC_COMP_FALSE| ( ) Bool)
+(declare-fun |h1| ( Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h8| ( Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h13| ( Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h12| ( Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h10| ( Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h23| ( Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h7| ( Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h17| ( Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h16| ( Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h3| ( Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h9| ( Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h11| ( Int Int Int Int Int Int Int Int ) Bool)
+(declare-fun |h5| ( Int Int Int Int Int Int Int Int ) Bool)
+
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (v_4 Int) (v_5 Int) (v_6 Int) (v_7 Int) ) 
+    (=>
+      (and
+        (and true (= v_4 A) (= v_5 B) (= v_6 C) (= v_7 D))
+      )
+      (h1 A B C D v_4 v_5 v_6 v_7)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) ) 
+    (=>
+      (and
+        (h1 A B C D E I J K)
+        (and (= F 0) (= H 0) (= G 0))
+      )
+      (h2 A B C D E F G H)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) ) 
+    (=>
+      (and
+        (h2 A B C D E F G H)
+        true
+      )
+      (h3 A B C D E F G H)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) ) 
+    (=>
+      (and
+        (h3 A B C D E F G H)
+        true
+      )
+      (h4 A B C D E F G H)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) ) 
+    (=>
+      (and
+        (h4 A B C D E F G H)
+        true
+      )
+      (h5 A B C D E F G H)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) ) 
+    (=>
+      (and
+        (h15 A B C D E F G H)
+        true
+      )
+      (h5 A B C D E F G H)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) ) 
+    (=>
+      (and
+        (h16 A B C D E F G H)
+        true
+      )
+      (h5 A B C D E F G H)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) ) 
+    (=>
+      (and
+        (h14 A B C D E F G H)
+        true
+      )
+      (h5 A B C D E F G H)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) ) 
+    (=>
+      (and
+        (h5 A B C D E F G H)
+        true
+      )
+      (h6 A B C D E F G H)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) ) 
+    (=>
+      (and
+        (h6 A B C D E F G H)
+        (>= (+ E (* (- 1) H)) 1)
+      )
+      (h7 A B C D E F G H)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) ) 
+    (=>
+      (and
+        (h7 A B C D E J G I)
+        (and (= I (+ (- 1) H)) (= J (+ (- 1) F)))
+      )
+      (h8 A B C D E F G H)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) ) 
+    (=>
+      (and
+        (h6 A B C D E F G H)
+        (<= (+ E (* (- 1) H)) 0)
+      )
+      (h9 A B C D E F G H)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) ) 
+    (=>
+      (and
+        (h9 A B C D E F G H)
+        true
+      )
+      (h10 A B C D E F G H)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) ) 
+    (=>
+      (and
+        (h10 A B C D E F G H)
+        true
+      )
+      (h11 A B C D E F G H)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) ) 
+    (=>
+      (and
+        (h8 A B C D E F G H)
+        true
+      )
+      (h12 A B C D E F G H)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) ) 
+    (=>
+      (and
+        (h12 A B C D E F G H)
+        (= (mod H 2) 0)
+      )
+      (h13 A B C D E F G H)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) ) 
+    (=>
+      (and
+        (h13 A B C D E F I H)
+        (= I (+ (- 1) G))
+      )
+      (h14 A B C D E F G H)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) ) 
+    (=>
+      (and
+        (h12 A B C D E F G H)
+        (not (= (mod H 2) 0))
+      )
+      (h15 A B C D E F G H)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) ) 
+    (=>
+      (and
+        (h12 A B C D E F G H)
+        (not (= (mod H 2) 0))
+      )
+      (h16 A B C D E F G H)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) ) 
+    (=>
+      (and
+        (h11 A B C D E F G H)
+        true
+      )
+      (h17 A B C D E F G H)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) ) 
+    (=>
+      (and
+        (h17 A B C D E F G H)
+        (= (mod H 2) 0)
+      )
+      (h18 A B C D E F G H)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) ) 
+    (=>
+      (and
+        (h18 A B C D E F G H)
+        true
+      )
+      (h19 A B C D E F G H)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) ) 
+    (=>
+      (and
+        (h19 A B C D E F G H)
+        (<= (+ F (* (- 2) G)) (- 1))
+      )
+      (h23 A B C D E F G H)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) ) 
+    (=>
+      (and
+        (h19 A B C D E F G H)
+        (>= (+ F (* (- 2) G)) 1)
+      )
+      (h24 A B C D E F G H)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) ) 
+    (=>
+      (and
+        (h23 A B C D E F G H)
+        true
+      )
+      CHC_COMP_FALSE
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) ) 
+    (=>
+      (and
+        (h24 A B C D E F G H)
+        true
+      )
+      CHC_COMP_FALSE
+    )
+  )
+)
+(assert
+  (forall ( (CHC_COMP_UNUSED Bool) ) 
+    (=>
+      (and
+        CHC_COMP_FALSE
+      )
+      false
+    )
+  )
+)
+
+(check-sat)
+(exit)
diff --git a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
index a37d0f1969..03578ad86f 100644
--- a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
+++ b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
@@ -120,8 +120,9 @@ public void hornJavaSMTPredicate() throws Exception {
   @SuppressWarnings("DefaultCharset")
   private HornProverEnvironment solveSmtLib2(final String file) throws Exception {
     var input =
-        new String(HornExampleTest.class.getResourceAsStream("/org/sosy_lab/java_smt/test/horn/" + file +
-            ".smt2").readAllBytes());
+        new String(
+            HornExampleTest.class.getResourceAsStream("/org/sosy_lab/java_smt/test/horn/" + file +
+                ".smt2").readAllBytes());
 
     final var context = SolverContextFactory.createSolverContext(Solvers.ELDARICA);
 
@@ -159,6 +160,34 @@ public void smt_ch_triangle_location_nr_2_bv_000() throws Exception {
     assertTrue(prover.isUnsat());
   }
 
+  @Test
+  public void smt_prusti_3_pass_paper_Examples_points_compress_000() throws Exception {
+    var prover = solveSmtLib2("prusti-3-pass-paper_examples-points-compress_000");
+
+    assertFalse(prover.isUnsat());
+  }
+
+  // @Test // TODO: enable when https://github.com/sosy-lab/java-smt/issues/682 is fixed
+  public void smt_38_c_000() throws Exception {
+    var prover = solveSmtLib2("38.c_000");
+
+    assertFalse(prover.isUnsat());
+  }
+
+  @Test
+  public void smt_two_counters_e3_325_000() throws Exception {
+    var prover = solveSmtLib2("two_counters_e3_325_000");
+
+    assertTrue(prover.isUnsat());
+  }
+
+  @Test
+  public void smt_O0_fibo_10_false_unreach_call_000() throws Exception {
+    var prover = solveSmtLib2("O0_fibo_10_false-unreach-call_000");
+
+    assertTrue(prover.isUnsat());
+  }
+
   @Test
   public void smt_small_unsat() throws Exception {
     /*
diff --git a/src/org/sosy_lab/java_smt/test/horn/O0_fibo_10_false-unreach-call_000.license b/src/org/sosy_lab/java_smt/test/horn/O0_fibo_10_false-unreach-call_000.license
new file mode 100644
index 0000000000..1abba28dd5
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/O0_fibo_10_false-unreach-call_000.license
@@ -0,0 +1 @@
+SPDX-License-Identifier: Apache-2.0
diff --git a/src/org/sosy_lab/java_smt/test/horn/O0_fibo_10_false-unreach-call_000.smt2 b/src/org/sosy_lab/java_smt/test/horn/O0_fibo_10_false-unreach-call_000.smt2
new file mode 100644
index 0000000000..47956f8a66
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/O0_fibo_10_false-unreach-call_000.smt2
@@ -0,0 +1,143 @@
+(set-logic HORN)
+
+
+(declare-fun |fibo| ( Bool Bool Bool Int Int ) Bool)
+(declare-fun |main@verifier.error.split| ( ) Bool)
+(declare-fun |main@entry| ( ) Bool)
+(declare-fun |fibo@_call| ( Int ) Bool)
+(declare-fun |fibo@.split| ( Int Int ) Bool)
+
+(assert
+  (forall ( (A Int) (B Int) (v_2 Bool) (v_3 Bool) (v_4 Bool) ) 
+    (=>
+      (and
+        (and true (= v_2 true) (= v_3 true) (= v_4 true))
+      )
+      (fibo v_2 v_3 v_4 A B)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (v_2 Bool) (v_3 Bool) (v_4 Bool) ) 
+    (=>
+      (and
+        (and true (= v_2 false) (= v_3 true) (= v_4 true))
+      )
+      (fibo v_2 v_3 v_4 A B)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (v_2 Bool) (v_3 Bool) (v_4 Bool) ) 
+    (=>
+      (and
+        (and true (= v_2 false) (= v_3 false) (= v_4 false))
+      )
+      (fibo v_2 v_3 v_4 A B)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (v_2 Bool) (v_3 Bool) (v_4 Bool) ) 
+    (=>
+      (and
+        (fibo@.split B A)
+        (and (= v_2 true) (= v_3 false) (= v_4 false))
+      )
+      (fibo v_2 v_3 v_4 A B)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) ) 
+    (=>
+      (and
+        true
+      )
+      (fibo@_call A)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Bool) (G Bool) (H Bool) (I Int) (J Bool) (K Bool) (L Int) (M Bool) (N Bool) (O Int) (P Bool) (Q Bool) (R Int) (S Int) (v_19 Bool) (v_20 Bool) (v_21 Bool) (v_22 Bool) ) 
+    (=>
+      (and
+        (fibo@_call S)
+        (fibo H v_19 v_20 A C)
+        (fibo H v_21 v_22 B D)
+        (and (= v_19 false)
+     (= v_20 false)
+     (= v_21 false)
+     (= v_22 false)
+     (or (not P) (and P H) (and N M) (and K J))
+     (or (not J) (not H) (not F))
+     (or (not K) (not J) (= L 1))
+     (or (not K) (not J) (= R L))
+     (or (not K) (not J) F)
+     (or (not M) (not J) (not G))
+     (or (not N) (not M) (= O 0))
+     (or (not N) (not M) (= R O))
+     (or (not N) (not M) G)
+     (or (not P) (not H) (= I E))
+     (or (not P) (not H) (= R I))
+     (or (not H) (= A (+ (- 1) S)))
+     (or (not H) (= B (+ (- 2) S)))
+     (or (not H) (= E (+ C D)))
+     (or (not H) (and J H))
+     (or (not J) (= F (= S 1)))
+     (or (not J) (and M J))
+     (or (not K) J)
+     (or (not N) M)
+     (or (not Q) (and Q P))
+     (= Q true)
+     (not (= (<= 1 S) G)))
+      )
+      (fibo@.split R S)
+    )
+  )
+)
+(assert
+  (forall ( (CHC_COMP_UNUSED Bool) ) 
+    (=>
+      (and
+        true
+      )
+      main@entry
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Bool) (C Bool) (D Bool) (E Bool) (F Bool) (v_6 Bool) (v_7 Bool) (v_8 Bool) (v_9 Int) ) 
+    (=>
+      (and
+        main@entry
+        (fibo v_6 v_7 v_8 v_9 A)
+        (and (= v_6 true)
+     (= v_7 false)
+     (= v_8 false)
+     (= 10 v_9)
+     (or (not D) (and D C))
+     (or (not E) (and E D))
+     (or (not F) (and F E))
+     (= B true)
+     (= F true)
+     (= B (= A 55)))
+      )
+      main@verifier.error.split
+    )
+  )
+)
+(assert
+  (forall ( (CHC_COMP_UNUSED Bool) ) 
+    (=>
+      (and
+        main@verifier.error.split
+        true
+      )
+      false
+    )
+  )
+)
+
+(check-sat)
+(exit)
diff --git a/src/org/sosy_lab/java_smt/test/horn/prusti-3-pass-paper_examples-points-compress_000.license b/src/org/sosy_lab/java_smt/test/horn/prusti-3-pass-paper_examples-points-compress_000.license
new file mode 100644
index 0000000000..1abba28dd5
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/prusti-3-pass-paper_examples-points-compress_000.license
@@ -0,0 +1 @@
+SPDX-License-Identifier: Apache-2.0
diff --git a/src/org/sosy_lab/java_smt/test/horn/prusti-3-pass-paper_examples-points-compress_000.smt2 b/src/org/sosy_lab/java_smt/test/horn/prusti-3-pass-paper_examples-points-compress_000.smt2
new file mode 100644
index 0000000000..c4b8f47f03
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/prusti-3-pass-paper_examples-points-compress_000.smt2
@@ -0,0 +1,77 @@
+(set-logic HORN)
+
+(declare-datatypes ((~Tup<%Point-%Point> 0) (%Point 0)) (((~tup<%Point-%Point>  (~at0/<%Point-%Point> %Point) (~at1/<%Point-%Point> %Point)))
+                                                         ((%Point-0  (%Point-0.0 Int) (%Point-0.1 Int)))))
+(declare-datatypes ((~Mut<%Point> 0)) (((~mut<%Point>  (~cur<%Point> %Point) (~ret<%Point> %Point)))))
+
+(declare-fun |%main.2| ( ~Tup<%Point-%Point> Int Bool Bool ) Bool)
+(declare-fun |%shift_x| ( ~Mut<%Point> Int ) Bool)
+(declare-fun |%main| ( Bool ) Bool)
+
+(assert
+  (forall ( (A Int) (B ~Mut<%Point>) (C Bool) (D Int) (E ~Tup<%Point-%Point>) (F Bool) (G ~Tup<%Point-%Point>) (H %Point) (I %Point) ) 
+    (=>
+      (and
+        (%main.2 E D C F)
+        (%shift_x B A)
+        (let ((a!1 (+ 1
+              (%Point-0.0 (~at0/<%Point-%Point> G))
+              (* (- 1) (%Point-0.0 (~at1/<%Point-%Point> G)))))
+      (a!2 (= C (<= (%Point-0.0 H) (%Point-0.0 (~at0/<%Point-%Point> G))))))
+  (and (= A a!1)
+       (= D a!1)
+       (= E (~tup<%Point-%Point> (~at0/<%Point-%Point> G) H))
+       a!2
+       (= H I)
+       (= B (~mut<%Point> (~at1/<%Point-%Point> G) I))))
+      )
+      (%main F)
+    )
+  )
+)
+(assert
+  (forall ( (A ~Tup<%Point-%Point>) (B Int) (C Bool) (v_3 Bool) ) 
+    (=>
+      (and
+        (and (not C) (= v_3 false))
+      )
+      (%main.2 A B v_3 C)
+    )
+  )
+)
+(assert
+  (forall ( (A ~Tup<%Point-%Point>) (B Int) (C Bool) (v_3 Bool) ) 
+    (=>
+      (and
+        (and (= C true) (= v_3 true))
+      )
+      (%main.2 A B v_3 C)
+    )
+  )
+)
+(assert
+  (forall ( (A ~Mut<%Point>) (B Int) ) 
+    (=>
+      (and
+        (let ((a!1 (%Point-0 (+ (%Point-0.0 (~cur<%Point> A)) B)
+                     (%Point-0.1 (~cur<%Point> A)))))
+  (= (~ret<%Point> A) a!1))
+      )
+      (%shift_x A B)
+    )
+  )
+)
+(assert
+  (forall ( (v_0 Bool) ) 
+    (=>
+      (and
+        (%main v_0)
+        (= v_0 true)
+      )
+      false
+    )
+  )
+)
+
+(check-sat)
+(exit)
diff --git a/src/org/sosy_lab/java_smt/test/horn/two_counters_e3_325_000.license b/src/org/sosy_lab/java_smt/test/horn/two_counters_e3_325_000.license
new file mode 100644
index 0000000000..1abba28dd5
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/two_counters_e3_325_000.license
@@ -0,0 +1 @@
+SPDX-License-Identifier: Apache-2.0
diff --git a/src/org/sosy_lab/java_smt/test/horn/two_counters_e3_325_000.smt2 b/src/org/sosy_lab/java_smt/test/horn/two_counters_e3_325_000.smt2
new file mode 100644
index 0000000000..73ecf0d676
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/two_counters_e3_325_000.smt2
@@ -0,0 +1,71 @@
+(set-logic HORN)
+
+
+(declare-fun |state| ( Int Bool Bool Int Bool Bool Bool Bool Bool Bool Bool Bool Int ) Bool)
+
+(assert
+  (forall ( (A Bool) (B Bool) (C Bool) (D Int) (E Int) (F Bool) (G Bool) (H Bool) (I Bool) (J Bool) (K Bool) (L Bool) (M Int) ) 
+    (=>
+      (and
+        (and (= E D)
+     (= (= D 2) J)
+     (= (= H G) F)
+     (= (and A K) I)
+     (= J H)
+     (= I G)
+     (= B K)
+     (= C A)
+     (not B)
+     (not C)
+     (= E 0))
+      )
+      (state E C B D J A K I H G F L M)
+    )
+  )
+)
+(assert
+  (forall ( (A Bool) (B Bool) (C Bool) (D Int) (E Int) (F Bool) (G Bool) (H Int) (I Int) (J Bool) (K Bool) (L Bool) (M Bool) (N Bool) (O Bool) (P Bool) (Q Int) (R Bool) (S Bool) (T Bool) (U Bool) (V Bool) (W Bool) (X Bool) (Y Int) (Z Bool) ) 
+    (=>
+      (and
+        (state E C B D V A W U T S R X Y)
+        (let ((a!1 (or (= D 3) (= (+ D (* (- 1) H)) 1))))
+  (and (= Q I)
+       (= E D)
+       (= (= Q 2) N)
+       (= (= D 2) V)
+       (= (= T S) R)
+       (= (= L K) J)
+       (= (and P O) M)
+       (= (and A W) U)
+       (= W G)
+       (= V T)
+       (= U S)
+       (= M K)
+       (= N L)
+       (= O F)
+       (= P G)
+       (= C A)
+       (= B W)
+       (not (= A F))
+       a!1
+       (or (not (= D 3)) (= H 0))
+       (= I H)))
+      )
+      (state I G F Q N P O M L K J Z H)
+    )
+  )
+)
+(assert
+  (forall ( (A Bool) (B Bool) (C Bool) (D Int) (E Int) (F Bool) (G Bool) (H Bool) (I Bool) (J Bool) (K Bool) (L Bool) (M Int) ) 
+    (=>
+      (and
+        (state E C B D J A K I H G F L M)
+        (not F)
+      )
+      false
+    )
+  )
+)
+
+(check-sat)
+(exit)

From 2c277f9abd6f4596729022fa21dc61b63c09c81d Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Mon, 29 Jun 2026 14:16:08 +0200
Subject: [PATCH 54/77] eldarica: add support for interval and int array sorts

---
 .../java_smt/solvers/princess/PrincessEnvironment.java    | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/PrincessEnvironment.java b/src/org/sosy_lab/java_smt/solvers/princess/PrincessEnvironment.java
index d57f82103d..d3c39c701d 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/PrincessEnvironment.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/PrincessEnvironment.java
@@ -616,6 +616,14 @@ private static FormulaType<?> getFormulaTypeFromSort(final Sort sort) {
         return FormulaType.getArrayType(FormulaType.IntegerType, FormulaType.IntegerType);
       }
       throw new IllegalArgumentException("Can not get formula type " + type);
+    } else if (sort instanceof Sort.Interval) {
+      if ("int".equals(sort.name())) {
+        return FormulaType.IntegerType;
+      }
+      if (sort.name().startsWith("int[")) {
+        return FormulaType.getArrayType(FormulaType.IntegerType, FormulaType.IntegerType);
+      }
+      throw new IllegalArgumentException("Can not get formula type " + sort.name());
     } else {
       // Check if it's a bitvector sort
       scala.Option<Object> bitWidth = getBitWidth(sort);

From fef85df3f408c5950a6a946552d3cefb029c8bfc Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Tue, 30 Jun 2026 13:35:35 +0200
Subject: [PATCH 55/77] readme: add eldarica horn solver

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index fe5483d51f..831bf15638 100644
--- a/README.md
+++ b/README.md
@@ -75,6 +75,7 @@ JavaSMT supports several SMT solvers (see [Getting Started](doc/Getting-started.
 | [Yices2](https://yices.csl.sri.com/)                                    | :heavy_check_mark:  |                     | :heavy_check_mark: |                    | [maybe](https://github.com/sosy-lab/java-smt/pull/400)⁴ |                    |                                                                             |
 | [Z3](https://github.com/Z3Prover/z3)                                    | :heavy_check_mark:³ | :heavy_check_mark:³ | :heavy_check_mark: | :heavy_check_mark: |                   :heavy_check_mark:                    | :heavy_check_mark: | mature and well-known solver                                                |
 | [Z3_WITH_INTERPOLATION](https://github.com/Z3Prover/z3)                 | :heavy_check_mark:  | :heavy_check_mark:  |                    |                    |                                                         |                    | an older version of Z3 that still provides interpolation support            |
+| [Eldarica](https://github.com/uuverifiers/eldarica)                     | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark: | :heavy_check_mark: |                   :heavy_check_mark:                    | :heavy_check_mark: | Java/Scala-based Horn solver                                                |
 
 We support a reasonable list of operating systems and versions.
 - Our main target is Linux (mainly Ubuntu or comparable Linux distributions).

From 9540ef432fc16f5ac12bcb63aa6179380e19d9b6 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Mon, 6 Jul 2026 13:37:43 +0200
Subject: [PATCH 56/77] web example: fix wrong princess version

---
 doc/Example-Maven-Web-Project/pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/Example-Maven-Web-Project/pom.xml b/doc/Example-Maven-Web-Project/pom.xml
index 86ae184c44..028cf0218d 100644
--- a/doc/Example-Maven-Web-Project/pom.xml
+++ b/doc/Example-Maven-Web-Project/pom.xml
@@ -82,7 +82,7 @@ SPDX-License-Identifier: Apache-2.0
     <mathsat.version>5.6.15</mathsat.version>
     <opensmt.version>2.9.0-gef441e1c</opensmt.version>
     <smtinterpol.version>2.5-1242-g5c50fb6d</smtinterpol.version>
-    <princess.version>2026-05-207</princess.version>
+    <princess.version>2026-05-20</princess.version>
     <ostrich.version>2.0</ostrich.version>
     <javasmt-yices.version>5.0.1-1258-gdad634a69</javasmt-yices.version>
     <yices.version>2.6.4-264-g553897f5</yices.version>

From 6b52461ae4ce6883ed834008314f427074c77f99 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Mon, 6 Jul 2026 13:42:53 +0200
Subject: [PATCH 57/77] horn tests: use parameterized test

---
 .../java_smt/test/SolverBasedTest0.java       |  8 ++++++++
 .../java_smt/test/horn/HornExampleTest.java   | 20 +++++++------------
 2 files changed, 15 insertions(+), 13 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/test/SolverBasedTest0.java b/src/org/sosy_lab/java_smt/test/SolverBasedTest0.java
index 509a7ea587..21e1aca587 100644
--- a/src/org/sosy_lab/java_smt/test/SolverBasedTest0.java
+++ b/src/org/sosy_lab/java_smt/test/SolverBasedTest0.java
@@ -364,6 +364,14 @@ protected final void requireBitvectorToInt() {
         .that(solverToUse())
         .isNotEqualTo(Solvers.YICES2);
   }
+  protected final void requireHorn() {
+    assume()
+        .withMessage(
+            "Solver %s does not yet support solving horn clauses",
+            solverToUse())
+        .that(solverToUse())
+        .isEqualTo(Solvers.ELDARICA);
+  }
 
   @SuppressWarnings("CheckReturnValue")
   protected final void requireFPToBitvector() {
diff --git a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
index 03578ad86f..874f5401c8 100644
--- a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
+++ b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
@@ -18,14 +18,13 @@
 import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
 import org.sosy_lab.java_smt.api.FormulaType;
 import org.sosy_lab.java_smt.api.HornProverEnvironment;
+import org.sosy_lab.java_smt.test.SolverBasedTest0;
 
-public class HornExampleTest {
-  // TODO: Test with all solvers, not just eldarica (ParameterizedSolverBasedTest0)
+public class HornExampleTest extends SolverBasedTest0.ParameterizedSolverBasedTest0  {
 
   @Test
   public void hornJavaSMT() throws Exception {
-    final var context = SolverContextFactory.createSolverContext(Solvers.ELDARICA);
-
+    requireHorn();
     var intf = context.getFormulaManager().getIntegerFormulaManager();
     var horn = context.getFormulaManager().getBooleanFormulaManager();
 
@@ -51,7 +50,6 @@ public void hornJavaSMT() throws Exception {
       assertFalse(prover.isUnsat());
     }
     {
-
       var prover = context.newHornProverEnvironment();
 
       prover.addConstraint(clause1);
@@ -64,8 +62,7 @@ public void hornJavaSMT() throws Exception {
 
   @Test
   public void hornJavaSMTPredicate() throws Exception {
-    final var context = SolverContextFactory.createSolverContext(Solvers.ELDARICA);
-
+    requireHorn();
     // Pretty much taken from https://github.com/uuverifiers/eldarica/blob/master/src/test/scala/lazabs/horn/HornAPI.scala#L55
     var integer = context.getFormulaManager().getIntegerFormulaManager();
     var horn = context.getFormulaManager().getBooleanFormulaManager();
@@ -119,12 +116,9 @@ public void hornJavaSMTPredicate() throws Exception {
 
   @SuppressWarnings("DefaultCharset")
   private HornProverEnvironment solveSmtLib2(final String file) throws Exception {
-    var input =
-        new String(
-            HornExampleTest.class.getResourceAsStream("/org/sosy_lab/java_smt/test/horn/" + file +
-                ".smt2").readAllBytes());
-
-    final var context = SolverContextFactory.createSolverContext(Solvers.ELDARICA);
+    requireHorn();
+    var path = "/org/sosy_lab/java_smt/test/horn/" + file + ".smt2";
+    var input = new String(HornExampleTest.class.getResourceAsStream(path).readAllBytes());
 
     var formula = context.getFormulaManager();
     var constraints = formula.parseAll(input);

From 2f5fd8e78540b79f632411cd0238e43d1379ae57 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Tue, 7 Jul 2026 15:18:29 +0200
Subject: [PATCH 58/77] eldarica: wip model generation

---
 .../java_smt/basicimpl/AbstractProver.java    |  2 +-
 .../solvers/princess/EldaricaHornProver.java  | 99 ++++++++++++++-----
 .../solvers/princess/EldaricaModel.java       | 73 ++++++++++++++
 .../eldarica/PrincessHornConverter.java       |  7 +-
 .../java_smt/test/horn/HornExampleTest.java   | 36 +++++--
 5 files changed, 185 insertions(+), 32 deletions(-)
 create mode 100644 src/org/sosy_lab/java_smt/solvers/princess/EldaricaModel.java

diff --git a/src/org/sosy_lab/java_smt/basicimpl/AbstractProver.java b/src/org/sosy_lab/java_smt/basicimpl/AbstractProver.java
index debe0d080f..f8de7dd138 100644
--- a/src/org/sosy_lab/java_smt/basicimpl/AbstractProver.java
+++ b/src/org/sosy_lab/java_smt/basicimpl/AbstractProver.java
@@ -151,7 +151,7 @@ protected final void checkEnableSeparationLogic() {
 
   protected abstract boolean hasPersistentModel();
 
-  private void setChanged() {
+  protected void setChanged() {
     wasLastSatCheckSatisfiable = false;
     if (!changedSinceLastSatQuery) {
       changedSinceLastSatQuery = true;
diff --git a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
index cd1296a88d..4aeb65d616 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
@@ -17,6 +17,9 @@
 import com.google.common.base.Preconditions;
 import java.io.PrintStream;
 import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Optional;
 import java.util.Set;
 import lazabs.GlobalParameters;
 import lazabs.horn.CEGARHornWrapper;
@@ -29,23 +32,28 @@
 import org.sosy_lab.common.ShutdownNotifier;
 import org.sosy_lab.java_smt.api.BooleanFormula;
 import org.sosy_lab.java_smt.api.HornProverEnvironment;
+import org.sosy_lab.java_smt.api.Model;
 import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
 import org.sosy_lab.java_smt.api.SolverException;
 import org.sosy_lab.java_smt.solvers.princess.eldarica.PrincessHornConverter;
 import scala.Console$;
 import scala.Function0;
+import scala.collection.JavaConverters;
 import scala.collection.immutable.Map;
 import scala.jdk.javaapi.CollectionConverters;
 import scala.util.Either;
 
-public class EldaricaHornProver extends PrincessAbstractProver<Void> implements
-                                                                     HornProverEnvironment {
-  //  private final HornAPI horn;
+public class EldaricaHornProver extends PrincessAbstractProver<Void>
+    implements HornProverEnvironment {
   private final ArrayList<Clause> clauses = new ArrayList<>();
   private final PrincessHornConverter converter = new PrincessHornConverter();
 
+  @Nullable
+  private Either<Function0<Map<Predicate, IFormula>>, Function0<Dag<IAtom>>> result = null;
+
   private static final boolean DEBUG_LOGGING = "true".equals(System.getenv("ELDARICA_DEBUG"));
 
+
   static {
     if (DEBUG_LOGGING) {
       GlobalParameters.get().setLogLevel(3);
@@ -56,6 +64,7 @@ public class EldaricaHornProver extends PrincessAbstractProver<Void> implements
     }
   }
 
+
   public EldaricaHornProver(
       PrincessFormulaManager pMgr,
       PrincessFormulaCreator creator,
@@ -63,41 +72,34 @@ public EldaricaHornProver(
       ShutdownNotifier pShutdownNotifier,
       Set<ProverOptions> pOptions) {
     super(pMgr, creator, pApi, pShutdownNotifier, pOptions);
-    // this.horn = new HornAPI(new HornAPI.CEGAROptions()); // TODO: options
   }
 
-  private void addConstraint1(BooleanFormula constraint) {
-    Preconditions.checkState(!closed);
 
-    final int formulaId = idGenerator.getFreshId();
-    partitions.push(partitions.pop().putAndCopy(formulaId, constraint));
-    api.setPartitionNumber(formulaId);
+  @Override
+  @Nullable
+  protected Void addConstraintImpl(BooleanFormula constraint) {
+    Preconditions.checkState(!closed);
 
     final IFormula formula = (IFormula) mgr.extractInfo(constraint);
-    // TODO: purpose?
-    var assertion =
-        api.abbrevSharedExpressions(formula, creator.getEnv().getMinAtomsForAbbreviation());
 
-    if (assertion.isFalse()) {
+    if (formula.isFalse()) {
       throw new RuntimeException("TODO: handle false");
     }
-    if (assertion.isTrue()) {
-      return;
+    if (formula.isTrue()) {
+      return null;
     }
 
-    var clause = converter.toClause(assertion);
+    var clause = converter.toClause(formula);
 
     this.clauses.add(clause);
-  }
 
-  @Override
-  @Nullable
-  protected Void addConstraintImpl(BooleanFormula constraint) throws InterruptedException {
-    addConstraint1(constraint);
     return null;
   }
 
   private Either<Function0<Map<Predicate, IFormula>>, Function0<Dag<IAtom>>> solve() {
+    if (this.result != null) {
+      return this.result;
+    }
     var stream = DEBUG_LOGGING ? System.err : new PrintStream(NullStream$.MODULE$);
 
     var err = Console$.MODULE$.err();
@@ -113,6 +115,7 @@ private Either<Function0<Map<Predicate, IFormula>>, Function0<Dag<IAtom>>> solve
           preprocessed._3(), false, stream).result();
 
 
+      this.result = result;
       return result;
     } finally {
       Console$.MODULE$.setErrDirect(err);
@@ -124,8 +127,58 @@ protected boolean isUnsatImpl() throws SolverException {
     var result = solve();
 
     return result.isRight();
-    // return !this.horn.isSat(CollectionConverters.asScala(this.clauses));
   }
 
-  // TODO: Model, push/pop?.
+  @Override
+  protected void setChanged() {
+    result = null;
+  }
+
+  @Override
+  public Model getModelImpl() throws SolverException {
+    var result = solve();
+    if (result.isRight()) {
+      throw new IllegalStateException("Unsat, no model available!");
+    }
+
+    var solution = result.left().get().apply();
+
+    return new EldaricaModel(JavaConverters.asJava(solution), this, creator);
+  }
+
+  @Override
+  public List<BooleanFormula> getUnsatCore() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public Optional<List<BooleanFormula>> unsatCoreOverAssumptions(Collection<BooleanFormula> assumptions) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public boolean isUnsatWithAssumptions(Collection<BooleanFormula> assumptions)
+      throws SolverException, InterruptedException {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  protected boolean hasPersistentModel() {
+    return false;
+  }
+
+  @Override
+  public @Nullable Void push(BooleanFormula f) throws InterruptedException {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  protected void popImpl() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  protected PrincessModel getEvaluatorWithoutChecks() throws SolverException {
+    throw new UnsupportedOperationException();
+  }
 }
diff --git a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaModel.java b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaModel.java
new file mode 100644
index 0000000000..9f5f88526b
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaModel.java
@@ -0,0 +1,73 @@
+/*
+ * This file is part of JavaSMT,
+ * an API wrapper for a collection of SMT solvers:
+ * https://github.com/sosy-lab/java-smt
+ *
+ * SPDX-FileCopyrightText: 2026 Dirk Beyer <https://www.sosy-lab.org>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.sosy_lab.java_smt.solvers.princess;
+
+import ap.parser.IExpression;
+import ap.parser.IFormula;
+import ap.terfor.preds.Predicate;
+import ap.types.Sort;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import java.util.ArrayList;
+import java.util.Map;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.sosy_lab.java_smt.basicimpl.AbstractModel;
+import org.sosy_lab.java_smt.basicimpl.FormulaCreator;
+
+public class EldaricaModel extends AbstractModel<IExpression, Sort, PrincessEnvironment> {
+  private final Map<Predicate, IFormula> model;
+
+  EldaricaModel(
+      Map<Predicate, IFormula> model, EldaricaHornProver prover,
+      FormulaCreator<IExpression, Sort, PrincessEnvironment, ?> creator) {
+    super(prover, creator);
+    this.model = model;
+  }
+
+  private ImmutableList<ValueAssignment> getAssignments(Predicate predicate, IFormula formula) {
+    // TODO: "{fun/2=(((-91 + _1) >= 0) & (((91 + -1 * _1) >= 0) | (((-10 + (_0 + -1 * _1)) >= 0) & ((-102 + _0) >= 0))))}"
+
+    var encapsulated = creator.encapsulateWithTypeOf(formula);
+
+
+    var assignment = new ValueAssignment(
+        encapsulated,
+        encapsulated,
+        creator.encapsulateBoolean(formula),
+        predicate.name(),
+        formula,
+        new ArrayList<>()
+        );
+
+    return ImmutableList.of(assignment);
+  }
+
+  @Override
+  public ImmutableList<ValueAssignment> asList() {
+    ImmutableSet.Builder<ValueAssignment> assignments = ImmutableSet.builder();
+
+    for (var entry : this.model.entrySet()) {
+      assignments.addAll(getAssignments(entry.getKey(), entry.getValue()));
+    }
+
+    return assignments.build().asList();
+  }
+
+  @Override
+  protected @Nullable IExpression evalImpl(IExpression formula) {
+    throw new UnsupportedOperationException(); // TODO?
+  }
+
+  @Override
+  public String toString() {
+    return model.toString();
+  }
+}
diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
index baa87b3362..0a3a5760b6 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -189,8 +189,8 @@ private IFormula toFormula(final IIntFormula i) {
           return toFormula(ite.cond().notSimplify());
         }
       }
-      if (i.t() instanceof ITermITE) {
-        throw new RuntimeException("ITE (TODO): " + i.t());
+      if (i.t() instanceof ITermITE ite) {
+        throw new RuntimeException("ITE (TODO): " + ite);
       }
       return new IIntFormula(i.rel(), toTerm(i.t()));
     }
@@ -313,6 +313,9 @@ private ITerm toTerm(final ITerm term) {
         return new IFunApp(fun.fun(), toTerm(fun.args()));
       }
       if (term instanceof ITermITE ite) {
+        // TODO: Most times this is already covered, as ITEs can only occur in Equations
+        //  (mostly EqZero). This could be handled by pushing/popping a stack and adding every
+        //  single possible case as constraint (or the fomular with OR)
         throw new IllegalArgumentException("Eldarica does not support ITE terms: " + ite);
       }
 
diff --git a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
index 874f5401c8..6e400c5c13 100644
--- a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
+++ b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
@@ -10,17 +10,19 @@
 
 package org.sosy_lab.java_smt.test.horn;
 
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 
 import org.junit.Test;
-import org.sosy_lab.java_smt.SolverContextFactory;
-import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
 import org.sosy_lab.java_smt.api.FormulaType;
 import org.sosy_lab.java_smt.api.HornProverEnvironment;
+import org.sosy_lab.java_smt.api.SolverContext;
+import org.sosy_lab.java_smt.api.SolverContext.ProverOptions;
 import org.sosy_lab.java_smt.test.SolverBasedTest0;
 
-public class HornExampleTest extends SolverBasedTest0.ParameterizedSolverBasedTest0  {
+public class HornExampleTest extends SolverBasedTest0.ParameterizedSolverBasedTest0 {
 
   @Test
   public void hornJavaSMT() throws Exception {
@@ -115,15 +117,19 @@ public void hornJavaSMTPredicate() throws Exception {
   }
 
   @SuppressWarnings("DefaultCharset")
-  private HornProverEnvironment solveSmtLib2(final String file) throws Exception {
+  private HornProverEnvironment solveSmtLib2(
+      final String file,
+      SolverContext.ProverOptions... options) throws Exception {
     requireHorn();
     var path = "/org/sosy_lab/java_smt/test/horn/" + file + ".smt2";
-    var input = new String(HornExampleTest.class.getResourceAsStream(path).readAllBytes());
+    var stream = HornExampleTest.class.getResourceAsStream(path);
+    var input = new String(stream.readAllBytes());
+    stream.close();
 
     var formula = context.getFormulaManager();
     var constraints = formula.parseAll(input);
 
-    var prover = context.newHornProverEnvironment();
+    var prover = context.newHornProverEnvironment(options);
 
     for (var constraint : constraints) {
       prover.addConstraint(constraint);
@@ -209,6 +215,24 @@ public void smt_small_sat() throws Exception {
     assertFalse(prover.isUnsat());
   }
 
+  @Test
+  public void smt_small_unsat_model() throws Exception {
+    var prover = solveSmtLib2("small_unsat", ProverOptions.GENERATE_MODELS);
+
+    prover.isUnsat();
+    assertThrows(Exception.class, () -> prover.getModel());
+  }
+
+  @Test
+  public void smt_small_sat_model() throws Exception {
+    var prover = solveSmtLib2("small_sat", ProverOptions.GENERATE_MODELS);
+
+    prover.isUnsat();
+    var model = prover.getModel().asList();
+
+    assertEquals("fun", model.iterator().next().getName());
+  }
+
   @SuppressWarnings("varargs")
   @SafeVarargs
   private <A> java.util.List<A> jList(A... vars) {

From 47555e702d247808d29ca4406a32f06af6a19782 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Thu, 9 Jul 2026 16:42:59 +0200
Subject: [PATCH 59/77] apply some suggestions

Co-authored-by: BaierD <daniel.baier@sosy.ifi.lmu.de>
---
 .../solvers/princess/EldaricaHornProver.java        | 13 +++----------
 1 file changed, 3 insertions(+), 10 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
index 4aeb65d616..7e7b49d8ca 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
@@ -124,9 +124,7 @@ private Either<Function0<Map<Predicate, IFormula>>, Function0<Dag<IAtom>>> solve
 
   @Override
   protected boolean isUnsatImpl() throws SolverException {
-    var result = solve();
-
-    return result.isRight();
+    return solve().isRight();
   }
 
   @Override
@@ -136,14 +134,9 @@ protected void setChanged() {
 
   @Override
   public Model getModelImpl() throws SolverException {
-    var result = solve();
-    if (result.isRight()) {
-      throw new IllegalStateException("Unsat, no model available!");
-    }
-
-    var solution = result.left().get().apply();
+    var model = solve().left().get().apply();
 
-    return new EldaricaModel(JavaConverters.asJava(solution), this, creator);
+    return new EldaricaModel(JavaConverters.asJava(model), this, creator);
   }
 
   @Override

From 75d01ade3f469bbd43e5eb21cb47d11fe1639906 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Sat, 11 Jul 2026 12:32:31 +0200
Subject: [PATCH 60/77] document EldaricaHornProver::solve

Co-authored-by: BaierD <daniel.baier@sosy.ifi.lmu.de>
---
 .../java_smt/solvers/princess/EldaricaHornProver.java         | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
index 7e7b49d8ca..cf522bb559 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
@@ -96,6 +96,10 @@ protected Void addConstraintImpl(BooleanFormula constraint) {
     return null;
   }
 
+  /**
+   * Passes all clauses to Eldarica and solves it
+   * @return Either (left) a model if sat, otherwise (right) a counter example.
+   */
   private Either<Function0<Map<Predicate, IFormula>>, Function0<Dag<IAtom>>> solve() {
     if (this.result != null) {
       return this.result;

From 729b52d517cfeff4ffec024cb29b8edc6f7e0055 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Sat, 11 Jul 2026 12:33:24 +0200
Subject: [PATCH 61/77] eldarica: avoid using this. and parameter shadowing

Daniel apparently does not like this, see https://github.com/sosy-lab/java-smt/pull/683#discussion_r3562278477

Co-authored-by: BaierD <daniel.baier@sosy.ifi.lmu.de>
---
 .../sosy_lab/java_smt/solvers/princess/EldaricaModel.java   | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaModel.java b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaModel.java
index 9f5f88526b..75fe4bc004 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaModel.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaModel.java
@@ -26,10 +26,10 @@ public class EldaricaModel extends AbstractModel<IExpression, Sort, PrincessEnvi
   private final Map<Predicate, IFormula> model;
 
   EldaricaModel(
-      Map<Predicate, IFormula> model, EldaricaHornProver prover,
+      Map<Predicate, IFormula> pModel, EldaricaHornProver prover,
       FormulaCreator<IExpression, Sort, PrincessEnvironment, ?> creator) {
     super(prover, creator);
-    this.model = model;
+    model = pModel;
   }
 
   private ImmutableList<ValueAssignment> getAssignments(Predicate predicate, IFormula formula) {
@@ -54,7 +54,7 @@ private ImmutableList<ValueAssignment> getAssignments(Predicate predicate, IForm
   public ImmutableList<ValueAssignment> asList() {
     ImmutableSet.Builder<ValueAssignment> assignments = ImmutableSet.builder();
 
-    for (var entry : this.model.entrySet()) {
+    for (var entry : model.entrySet()) {
       assignments.addAll(getAssignments(entry.getKey(), entry.getValue()));
     }
 

From cb11e42daf53c8374ec46d8480d3f2fa935d7969 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Sat, 11 Jul 2026 14:06:08 +0200
Subject: [PATCH 62/77] eldarica: model retrieving

This uses princess to evaluate the formula. Might not be perfect, as not all edge cases might be covered (but then it will just throw the exception)
---
 .../solvers/princess/EldaricaHornProver.java  |  5 +-
 .../solvers/princess/EldaricaModel.java       | 81 +++++++++++++++++--
 .../java_smt/test/horn/HornExampleTest.java   | 12 ++-
 3 files changed, 89 insertions(+), 9 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
index cf522bb559..8bf437ee9c 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
@@ -114,9 +114,10 @@ private Either<Function0<Map<Predicate, IFormula>>, Function0<Dag<IAtom>>> solve
       var preprocessor = new DefaultPreprocessor();
       var preprocessed = preprocessor.process(clauses, EmptyVerificationHints$.MODULE$);
 
+      var wrapper = new CEGARHornWrapper(clauses, preprocessed._1(), preprocessed._2(),
+          preprocessed._3(), false, stream);
 
-      var result = new CEGARHornWrapper(clauses, preprocessed._1(), preprocessed._2(),
-          preprocessed._3(), false, stream).result();
+      var result = wrapper.result();
 
 
       this.result = result;
diff --git a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaModel.java b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaModel.java
index 75fe4bc004..9fda428d4f 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaModel.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaModel.java
@@ -10,20 +10,32 @@
 
 package org.sosy_lab.java_smt.solvers.princess;
 
+import ap.api.SimpleAPI;
+import ap.parser.IBinFormula;
+import ap.parser.IBoolLit;
+import ap.parser.IConstant;
 import ap.parser.IExpression;
 import ap.parser.IFormula;
+import ap.parser.IIntFormula;
+import ap.parser.IIntLit;
+import ap.parser.IPlus;
+import ap.parser.ISortedVariable;
+import ap.parser.ITerm;
+import ap.parser.ITimes;
 import ap.terfor.preds.Predicate;
 import ap.types.Sort;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import java.util.ArrayList;
 import java.util.Map;
-import org.checkerframework.checker.nullness.qual.Nullable;
+import javax.annotation.Nullable;
 import org.sosy_lab.java_smt.basicimpl.AbstractModel;
 import org.sosy_lab.java_smt.basicimpl.FormulaCreator;
+import scala.collection.JavaConverters;
 
 public class EldaricaModel extends AbstractModel<IExpression, Sort, PrincessEnvironment> {
   private final Map<Predicate, IFormula> model;
+  private final SimpleAPI api = SimpleAPI.spawn();
 
   EldaricaModel(
       Map<Predicate, IFormula> pModel, EldaricaHornProver prover,
@@ -33,8 +45,6 @@ public class EldaricaModel extends AbstractModel<IExpression, Sort, PrincessEnvi
   }
 
   private ImmutableList<ValueAssignment> getAssignments(Predicate predicate, IFormula formula) {
-    // TODO: "{fun/2=(((-91 + _1) >= 0) & (((91 + -1 * _1) >= 0) | (((-10 + (_0 + -1 * _1)) >= 0) & ((-102 + _0) >= 0))))}"
-
     var encapsulated = creator.encapsulateWithTypeOf(formula);
 
 
@@ -43,9 +53,9 @@ private ImmutableList<ValueAssignment> getAssignments(Predicate predicate, IForm
         encapsulated,
         creator.encapsulateBoolean(formula),
         predicate.name(),
-        formula,
+        evalAssignments(formula),
         new ArrayList<>()
-        );
+    );
 
     return ImmutableList.of(assignment);
   }
@@ -61,9 +71,68 @@ public ImmutableList<ValueAssignment> asList() {
     return assignments.build().asList();
   }
 
+  private ITerm toPrincess(ITerm term) {
+    if (term instanceof IPlus plus) {
+      return new IPlus(toPrincess(plus.t1()), toPrincess(plus.t2()));
+    }
+    if (term instanceof ITimes times) {
+      return new ITimes(times.coeff(), toPrincess(times.subterm()));
+    }
+    if (term instanceof IIntLit lit) {
+      return lit;
+    }
+    if (term instanceof IConstant constant) {
+      return constant;
+    }
+    if (term instanceof ISortedVariable variable) {
+      return api.createConstant("_" + variable.index(), variable.sort());
+    }
+
+    throw new IllegalArgumentException("Unhandled model term: " + term);
+  }
+
+  private IFormula toPrincess(IFormula formula) {
+    if (formula instanceof IBinFormula bin) {
+      return new IBinFormula(bin.j(), toPrincess(bin.f1()),
+          toPrincess(bin.f2()));
+    }
+    if (formula instanceof IIntFormula _int) {
+      return new IIntFormula(_int.rel(), toPrincess(_int.t()));
+    }
+    if (formula instanceof IBoolLit bool) {
+      return bool;
+    }
+    throw new IllegalArgumentException("Unhandled model formula: " + formula);
+  }
+
+  private Object toValue(IExpression expression) {
+    if (expression instanceof IIntLit lit) {
+      return lit.value().bigIntValue();
+    }
+
+
+    throw new IllegalArgumentException("Unhandled model value: " + expression);
+  }
+
+  private Object[] evalAssignments(IFormula formula) {
+    var converted = toPrincess(formula);
+
+    api.addAssertion(converted);
+    api.checkSat(true);
+    var model = api.partialModel().interpretation();
+
+    var output = new Object[model.size()];
+
+    for (var tuple : JavaConverters.asJava(model.view())) {
+      output[Integer.parseInt(((IConstant) tuple._1).c().name().substring(1))] = toValue(tuple._2);
+    }
+
+    return output;
+  }
+
   @Override
   protected @Nullable IExpression evalImpl(IExpression formula) {
-    throw new UnsupportedOperationException(); // TODO?
+    throw new UnsupportedOperationException();
   }
 
   @Override
diff --git a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
index 6e400c5c13..f9bb6d22d0 100644
--- a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
+++ b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
@@ -12,9 +12,11 @@
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 
+import java.math.BigInteger;
 import org.junit.Test;
 import org.sosy_lab.java_smt.api.FormulaType;
 import org.sosy_lab.java_smt.api.HornProverEnvironment;
@@ -230,7 +232,15 @@ public void smt_small_sat_model() throws Exception {
     prover.isUnsat();
     var model = prover.getModel().asList();
 
-    assertEquals("fun", model.iterator().next().getName());
+    assertEquals(1, model.size());
+
+    var fun = model.iterator().next();
+
+    assertEquals("fun", fun.getName());
+    assertTrue(fun.getAssignmentAsFormula().toString().contains("-91 + _1"));
+    var value = (Object[]) fun.getValue();
+    assertNull(value[0]); // does not matter
+    assertEquals(BigInteger.valueOf(91), value[1]);
   }
 
   @SuppressWarnings("varargs")

From c2faa77dedacd6a64d29fe8dc674a93519428c6c Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Sat, 11 Jul 2026 14:10:03 +0200
Subject: [PATCH 63/77] eldarica: handle bool models properly

---
 .../sosy_lab/java_smt/solvers/princess/EldaricaModel.java   | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaModel.java b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaModel.java
index 9fda428d4f..356fc216cd 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaModel.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaModel.java
@@ -109,6 +109,9 @@ private Object toValue(IExpression expression) {
     if (expression instanceof IIntLit lit) {
       return lit.value().bigIntValue();
     }
+    if (expression instanceof IBoolLit lit) {
+      return lit.value();
+    }
 
 
     throw new IllegalArgumentException("Unhandled model value: " + expression);
@@ -116,6 +119,9 @@ private Object toValue(IExpression expression) {
 
   private Object[] evalAssignments(IFormula formula) {
     var converted = toPrincess(formula);
+    if (formula instanceof IBoolLit lit && lit.isFalse()) {
+      return new Object[]{false};
+    }
 
     api.addAssertion(converted);
     api.checkSat(true);

From 2746273fee12b4a99d6657fcf0c5eb536f47d925 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Sat, 11 Jul 2026 14:17:34 +0200
Subject: [PATCH 64/77] eldarica horn prover: don't use var model

---
 .../sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
index 8bf437ee9c..9f3b31477f 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/EldaricaHornProver.java
@@ -139,7 +139,7 @@ protected void setChanged() {
 
   @Override
   public Model getModelImpl() throws SolverException {
-    var model = solve().left().get().apply();
+    Map<Predicate, IFormula> model = solve().left().get().apply();
 
     return new EldaricaModel(JavaConverters.asJava(model), this, creator);
   }

From ac1679085e652e0e6fee8dfb4b1b64839c19facd Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Mon, 20 Jul 2026 00:03:21 +0200
Subject: [PATCH 65/77] eldarica: rewrite epsilon terms and quantifier

---
 .../princess/eldarica/PrincessHornConverter.java     | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
index 0a3a5760b6..2f183babe9 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -24,6 +24,7 @@
 import ap.parser.IIntRelation;
 import ap.parser.INot;
 import ap.parser.IPlus;
+import ap.parser.ISortedEpsilon;
 import ap.parser.ISortedQuantified;
 import ap.parser.ISortedVariable;
 import ap.parser.ITerm;
@@ -235,6 +236,11 @@ private IFormula toFormula(final INot not) {
       return toFormula(not.subformula()).notSimplify();
     }
 
+    private ISortedQuantified toFormula(final ISortedQuantified quantified) {
+      return new ISortedQuantified(quantified.quan(), quantified.sort(),
+          toFormula(quantified.subformula()));
+    }
+
     private IFormula toFormula(final IFormulaITE ite) {
       var condition = toFormula(ite.cond());
 
@@ -267,6 +273,9 @@ private IFormula toFormula(final IFormula formula) {
       if (formula instanceof IFormulaITE ite) {
         return toFormula(ite);
       }
+      if (formula instanceof ISortedQuantified quantified) {
+        return toFormula(quantified);
+      }
 
       throw new IllegalArgumentException("Unhandled formula: " + formula);
     }
@@ -318,6 +327,9 @@ private ITerm toTerm(final ITerm term) {
         //  single possible case as constraint (or the fomular with OR)
         throw new IllegalArgumentException("Eldarica does not support ITE terms: " + ite);
       }
+      if (term instanceof ISortedEpsilon epsilon) {
+        return new ISortedEpsilon(epsilon.sort(), toFormula(epsilon.cond()));
+      }
 
       throw new IllegalArgumentException("Unhandled term: " + term);
     }

From c9b9ef4f0803219fb700d907606d2c4c79077409 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Mon, 20 Jul 2026 12:51:20 +0200
Subject: [PATCH 66/77] eldarica: fix rewriting of simple ite terms

---
 .../eldarica/PrincessHornConverter.java       | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
index 2f183babe9..2d2f8b435d 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -201,10 +201,13 @@ private IFormula toFormula(ITerm value, ITermITE ite) {
 
       var condition = toFormula(ite.cond());
 
-      var a = condition.andSimplify(new IEquation(value, toTerm(ite.left())));
-      var b = condition.notSimplify().andSimplify(new IEquation(value, toTerm(ite.right())));
+      var left = toTerm(ite.left());
+      var right = toTerm(ite.right());
 
-      return a.orSimplify(b);
+      var a = condition.andSimplify(new IEquation(value, left));
+      var b = condition.notSimplify().andSimplify(new IEquation(value, right));
+
+      return a.andSimplify(b);
     }
 
     private IFormula toFormula(final IEquation equation) {
@@ -244,11 +247,14 @@ private ISortedQuantified toFormula(final ISortedQuantified quantified) {
     private IFormula toFormula(final IFormulaITE ite) {
       var condition = toFormula(ite.cond());
 
-      var a = condition.andSimplify(toFormula(ite.left()));
-      var b = condition.notSimplify().andSimplify(toFormula(ite.right()));
+      var left = toFormula(ite.left());
+      var right = toFormula(ite.right());
+
+      var a = condition.andSimplify(left);
+      var b = condition.notSimplify().andSimplify(right);
 
 
-      return a.orSimplify(b);
+      return a.andSimplify(b);
     }
 
     private IFormula toFormula(final IFormula formula) {
@@ -328,6 +334,7 @@ private ITerm toTerm(final ITerm term) {
         throw new IllegalArgumentException("Eldarica does not support ITE terms: " + ite);
       }
       if (term instanceof ISortedEpsilon epsilon) {
+
         return new ISortedEpsilon(epsilon.sort(), toFormula(epsilon.cond()));
       }
 

From 59d3aa89085454a02c26c0d874cb84f0aba66fd2 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Mon, 20 Jul 2026 12:53:43 +0200
Subject: [PATCH 67/77] horn: test for epsilon rewriting and quation ite
 rewriting

---
 .../java_smt/test/horn/HornExampleTest.java   | 10 ++++
 .../java_smt/test/horn/s_split_18_000.license |  1 +
 .../java_smt/test/horn/s_split_18_000.smt2    | 52 +++++++++++++++++++
 3 files changed, 63 insertions(+)
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/s_split_18_000.license
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/s_split_18_000.smt2

diff --git a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
index f9bb6d22d0..d3d8b46e67 100644
--- a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
+++ b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
@@ -176,6 +176,15 @@ public void smt_38_c_000() throws Exception {
     assertFalse(prover.isUnsat());
   }
 
+
+  // @Test // TODO: enable when https://github.com/sosy-lab/java-smt/issues/682 is fixed
+  public void smt_s_split_18_000() throws Exception {
+    // test for rewriting equation ITE terms and epsilon terms
+    var prover = solveSmtLib2("s_split_18_000");
+
+    assertFalse(prover.isUnsat());
+  }
+
   @Test
   public void smt_two_counters_e3_325_000() throws Exception {
     var prover = solveSmtLib2("two_counters_e3_325_000");
@@ -239,6 +248,7 @@ public void smt_small_sat_model() throws Exception {
     assertEquals("fun", fun.getName());
     assertTrue(fun.getAssignmentAsFormula().toString().contains("-91 + _1"));
     var value = (Object[]) fun.getValue();
+    assertEquals(2, value.length);
     assertNull(value[0]); // does not matter
     assertEquals(BigInteger.valueOf(91), value[1]);
   }
diff --git a/src/org/sosy_lab/java_smt/test/horn/s_split_18_000.license b/src/org/sosy_lab/java_smt/test/horn/s_split_18_000.license
new file mode 100644
index 0000000000..1abba28dd5
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/s_split_18_000.license
@@ -0,0 +1 @@
+SPDX-License-Identifier: Apache-2.0
diff --git a/src/org/sosy_lab/java_smt/test/horn/s_split_18_000.smt2 b/src/org/sosy_lab/java_smt/test/horn/s_split_18_000.smt2
new file mode 100644
index 0000000000..0802af1c95
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/s_split_18_000.smt2
@@ -0,0 +1,52 @@
+(set-logic HORN)
+
+
+(declare-fun |fail| ( ) Bool)
+(declare-fun |inv| ( Int Int ) Bool)
+
+(assert
+  (forall ( (A Int) (B Int) ) 
+    (=>
+      (and
+        (and (= B 1) (= A 1))
+      )
+      (inv A B)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) ) 
+    (=>
+      (and
+        (inv B A)
+        (and (= D (ite (<= 16 A) (mod B 16) (* 2 A))) (= C (* 2 B)))
+      )
+      (inv C D)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) ) 
+    (=>
+      (and
+        (inv A B)
+        (and (not (<= A 16)) (not (= 0 B)))
+      )
+      fail
+    )
+  )
+)
+(assert
+  (forall ( (CHC_COMP_UNUSED Bool) ) 
+    (=>
+      (and
+        fail
+        true
+      )
+      false
+    )
+  )
+)
+
+(check-sat)
+(exit)

From 8628f9596e07c6ae03afb035829b3720397fd5b5 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Mon, 20 Jul 2026 13:06:33 +0200
Subject: [PATCH 68/77] only temporary disable some tests for eldarica, not
 horn in general

---
 .../sosy_lab/java_smt/test/horn/HornExampleTest.java | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
index d3d8b46e67..af3a7d4d42 100644
--- a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
+++ b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
@@ -10,6 +10,7 @@
 
 package org.sosy_lab.java_smt.test.horn;
 
+import static com.google.common.truth.TruthJUnit.assume;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNull;
@@ -18,6 +19,7 @@
 
 import java.math.BigInteger;
 import org.junit.Test;
+import org.sosy_lab.java_smt.SolverContextFactory.Solvers;
 import org.sosy_lab.java_smt.api.FormulaType;
 import org.sosy_lab.java_smt.api.HornProverEnvironment;
 import org.sosy_lab.java_smt.api.SolverContext;
@@ -169,17 +171,21 @@ public void smt_prusti_3_pass_paper_Examples_points_compress_000() throws Except
     assertFalse(prover.isUnsat());
   }
 
-  // @Test // TODO: enable when https://github.com/sosy-lab/java-smt/issues/682 is fixed
+  @Test
   public void smt_38_c_000() throws Exception {
+    // TODO: enable when https://github.com/sosy-lab/java-smt/issues/682 is fixed
+    assume().that(solver).isNotEqualTo(Solvers.ELDARICA);
     var prover = solveSmtLib2("38.c_000");
 
     assertFalse(prover.isUnsat());
   }
 
 
-  // @Test // TODO: enable when https://github.com/sosy-lab/java-smt/issues/682 is fixed
+  // test for rewriting equation ITE terms and epsilon terms
+  @Test
   public void smt_s_split_18_000() throws Exception {
-    // test for rewriting equation ITE terms and epsilon terms
+    // TODO: enable when https://github.com/sosy-lab/java-smt/issues/682 is fixed
+    assume().that(solver).isNotEqualTo(Solvers.ELDARICA);
     var prover = solveSmtLib2("s_split_18_000");
 
     assertFalse(prover.isUnsat());

From 53a88217e83f518d843d57291b51cfddab990fd6 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Mon, 20 Jul 2026 13:15:30 +0200
Subject: [PATCH 69/77] eldarica: explain better why ite is not supported

---
 .../princess/eldarica/PrincessHornConverter.java       |  8 ++++----
 .../sosy_lab/java_smt/test/horn/HornExampleTest.java   | 10 ++++++++++
 src/org/sosy_lab/java_smt/test/horn/rewrite_ite.smt2   |  9 +++++++++
 3 files changed, 23 insertions(+), 4 deletions(-)
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/rewrite_ite.smt2

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
index 2d2f8b435d..8902290def 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -328,13 +328,13 @@ private ITerm toTerm(final ITerm term) {
         return new IFunApp(fun.fun(), toTerm(fun.args()));
       }
       if (term instanceof ITermITE ite) {
-        // TODO: Most times this is already covered, as ITEs can only occur in Equations
-        //  (mostly EqZero). This could be handled by pushing/popping a stack and adding every
-        //  single possible case as constraint (or the fomular with OR)
+        // TODO: Most times this is already covered, as ITEs should only occur in equations
+        //  This would need to do some clause splitting (emitting one clause for if/else)
+        //  Or creating a temporary variable (as Eldarica does), but it gets sometimes optimized
+        //  away and returns wrong results
         throw new IllegalArgumentException("Eldarica does not support ITE terms: " + ite);
       }
       if (term instanceof ISortedEpsilon epsilon) {
-
         return new ISortedEpsilon(epsilon.sort(), toFormula(epsilon.cond()));
       }
 
diff --git a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
index af3a7d4d42..b56b170604 100644
--- a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
+++ b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
@@ -191,6 +191,16 @@ public void smt_s_split_18_000() throws Exception {
     assertFalse(prover.isUnsat());
   }
 
+  // test for rewriting deep nested ITE terms
+  @Test
+  public void smt_rewrite_ite() throws Exception {
+    // TODO: enable when complex ITE term rewriting is supported
+    assume().that(solver).isNotEqualTo(Solvers.ELDARICA);
+    var prover = solveSmtLib2("rewrite_ite");
+
+    assertFalse(prover.isUnsat());
+  }
+
   @Test
   public void smt_two_counters_e3_325_000() throws Exception {
     var prover = solveSmtLib2("two_counters_e3_325_000");
diff --git a/src/org/sosy_lab/java_smt/test/horn/rewrite_ite.smt2 b/src/org/sosy_lab/java_smt/test/horn/rewrite_ite.smt2
new file mode 100644
index 0000000000..6fd2e2901e
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/rewrite_ite.smt2
@@ -0,0 +1,9 @@
+(set-logic HORN)
+
+(declare-fun fun (Int) Bool)
+
+(assert
+  (forall ((x Int))
+    (=>
+      (fun x)
+      (fun (ite (<= x 0) (- x) x)))))

From 11d5b1bcf99bf6fcd565ac78c8ead7ff17667ef2 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Mon, 20 Jul 2026 13:47:44 +0200
Subject: [PATCH 70/77] eldarica: properly rewrite ite terms

---
 .../eldarica/PrincessHornConverter.java       | 33 +++++++++++++++----
 .../java_smt/test/horn/HornExampleTest.java   |  2 --
 2 files changed, 27 insertions(+), 8 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
index 8902290def..211eefaa49 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -50,6 +50,7 @@
 @SuppressWarnings({"unchecked", "PatternMatchingInstanceof"})
 public class PrincessHornConverter {
   private final ArrayList<Predicate> predicates = new ArrayList<>();
+  private int temporary = 0;
 
   private Predicate toPredicate(final MonoSortedIFunction function) {
     // Predicate does not implement hashCode nor equals, this deduplicates the objects.
@@ -308,6 +309,30 @@ private IConstant toVariable(final ISortedVariable variable) {
       return constant;
     }
 
+    private IConstant createVariable(String prefix, int index) {
+      return new IConstant(new ConstantTerm(prefix + index));
+    }
+
+    private ITerm toTerm(final ISortedEpsilon epsilon) {
+      throw new IllegalArgumentException("Epsilon terms are not supported at the moment");
+    }
+
+    private ITerm toTerm(final ITermITE ite) {
+      var variable = createVariable("T", temporary++);
+      var condition = toFormula(ite.cond());
+
+      var left = toTerm(ite.left());
+      var right = toTerm(ite.right());
+
+      var a = condition.andSimplify(new IEquation(variable, left));
+      var b = condition.notSimplify().andSimplify(new IEquation(variable, right));
+
+      this.constraint = this.constraint.andSimplify(a.andSimplify(b));
+
+
+      return variable;
+    }
+
     private ITerm toTerm(final ITerm term) {
       if (term instanceof IIntLit lit) {
         return lit;
@@ -328,14 +353,10 @@ private ITerm toTerm(final ITerm term) {
         return new IFunApp(fun.fun(), toTerm(fun.args()));
       }
       if (term instanceof ITermITE ite) {
-        // TODO: Most times this is already covered, as ITEs should only occur in equations
-        //  This would need to do some clause splitting (emitting one clause for if/else)
-        //  Or creating a temporary variable (as Eldarica does), but it gets sometimes optimized
-        //  away and returns wrong results
-        throw new IllegalArgumentException("Eldarica does not support ITE terms: " + ite);
+        return toTerm(ite);
       }
       if (term instanceof ISortedEpsilon epsilon) {
-        return new ISortedEpsilon(epsilon.sort(), toFormula(epsilon.cond()));
+        return toTerm(epsilon);
       }
 
       throw new IllegalArgumentException("Unhandled term: " + term);
diff --git a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
index b56b170604..c1d34da9fb 100644
--- a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
+++ b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
@@ -194,8 +194,6 @@ public void smt_s_split_18_000() throws Exception {
   // test for rewriting deep nested ITE terms
   @Test
   public void smt_rewrite_ite() throws Exception {
-    // TODO: enable when complex ITE term rewriting is supported
-    assume().that(solver).isNotEqualTo(Solvers.ELDARICA);
     var prover = solveSmtLib2("rewrite_ite");
 
     assertFalse(prover.isUnsat());

From 3fb974922ea589d3e3a8b3597868963477cb6126 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Mon, 20 Jul 2026 13:59:27 +0200
Subject: [PATCH 71/77] properly rewrite epsilon terms

---
 .../eldarica/PrincessHornConverter.java       | 36 ++++++++++++++-----
 1 file changed, 27 insertions(+), 9 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
index 211eefaa49..2fe34c24d1 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -35,6 +35,7 @@
 import ap.terfor.preds.Predicate;
 import ap.types.MonoSortedIFunction;
 import ap.types.MonoSortedPredicate;
+import ap.types.Sort;
 import ap.types.Sort.Integer$;
 import ap.types.SortedConstantTerm;
 import java.util.ArrayList;
@@ -50,7 +51,6 @@
 @SuppressWarnings({"unchecked", "PatternMatchingInstanceof"})
 public class PrincessHornConverter {
   private final ArrayList<Predicate> predicates = new ArrayList<>();
-  private int temporary = 0;
 
   private Predicate toPredicate(final MonoSortedIFunction function) {
     // Predicate does not implement hashCode nor equals, this deduplicates the objects.
@@ -72,8 +72,10 @@ private Predicate toPredicate(final MonoSortedIFunction function) {
   }
 
   class ClauseContext {
-    private final ArrayList<IConstant> parameters = new ArrayList<>();
+    private final ArrayList<IConstant> variables = new ArrayList<>();
     private IFormula constraint = new IBoolLit(true);
+    private int temporary = 0;
+    private boolean epsilon = false;
 
 
     private List<IFormula> flatten(final IBinFormula input) {
@@ -287,10 +289,10 @@ private IFormula toFormula(final IFormula formula) {
       throw new IllegalArgumentException("Unhandled formula: " + formula);
     }
 
-    private IConstant toVariable(final ISortedVariable variable) {
-      var name = "V" + variable.index();
+    private IConstant toVariable(int index, Sort sort) {
+      var name = "V" + index;
 
-      for (IConstant constant : parameters) {
+      for (IConstant constant : variables) {
         if (constant.c().name().equals(name)) {
           return constant;
         }
@@ -298,15 +300,20 @@ private IConstant toVariable(final ISortedVariable variable) {
 
       ConstantTerm term;
 
-      if (variable.sort() == Integer$.MODULE$) {
+      if (sort == Integer$.MODULE$) {
         term = new ConstantTerm(name);
       } else {
-        term = new SortedConstantTerm(name, variable.sort());
+        term = new SortedConstantTerm(name, sort);
       }
 
       var constant = new IConstant(term);
-      parameters.add(constant);
+      variables.add(constant);
       return constant;
+
+    }
+
+    private IConstant toVariable(final ISortedVariable variable) {
+      return toVariable(variable.index(), variable.sort());
     }
 
     private IConstant createVariable(String prefix, int index) {
@@ -314,7 +321,18 @@ private IConstant createVariable(String prefix, int index) {
     }
 
     private ITerm toTerm(final ISortedEpsilon epsilon) {
-      throw new IllegalArgumentException("Epsilon terms are not supported at the moment");
+      if (this.epsilon) {
+        throw new IllegalStateException("Can not nest epsilon terms (yet)!");
+      }
+      this.epsilon = true;
+
+      var variable = toVariable(0, epsilon.sort());
+      var condition = toFormula(epsilon.cond());
+
+      this.constraint = this.constraint.andSimplify(condition);
+
+      this.epsilon = false;
+      return variable;
     }
 
     private ITerm toTerm(final ITermITE ite) {

From df6ec6a5263e781e262742059df28e74ca66a247 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Mon, 20 Jul 2026 14:21:29 +0200
Subject: [PATCH 72/77] eldarica: don't support quantifiers inside formula

---
 .../eldarica/PrincessHornConverter.java       | 10 ++---
 .../java_smt/test/horn/HornExampleTest.java   |  9 +++++
 .../java_smt/test/horn/s_split_09_000.license |  1 +
 .../java_smt/test/horn/s_split_09_000.smt2    | 40 +++++++++++++++++++
 4 files changed, 55 insertions(+), 5 deletions(-)
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/s_split_09_000.license
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/s_split_09_000.smt2

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
index 2fe34c24d1..f8a8cc0332 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -193,9 +193,6 @@ private IFormula toFormula(final IIntFormula i) {
           return toFormula(ite.cond().notSimplify());
         }
       }
-      if (i.t() instanceof ITermITE ite) {
-        throw new RuntimeException("ITE (TODO): " + ite);
-      }
       return new IIntFormula(i.rel(), toTerm(i.t()));
     }
 
@@ -243,8 +240,11 @@ private IFormula toFormula(final INot not) {
     }
 
     private ISortedQuantified toFormula(final ISortedQuantified quantified) {
-      return new ISortedQuantified(quantified.quan(), quantified.sort(),
-          toFormula(quantified.subformula()));
+      // TODO: Eldarica supports this, but the variables need to be rewritten
+      throw new IllegalArgumentException(
+          "Quantifiers inside formulas are not supported yet: " + quantified);
+      // return new ISortedQuantified(quantified.quan(), quantified.sort(),
+      //    toFormula(quantified.subformula()));
     }
 
     private IFormula toFormula(final IFormulaITE ite) {
diff --git a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
index c1d34da9fb..1e6e926cbb 100644
--- a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
+++ b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
@@ -180,6 +180,15 @@ public void smt_38_c_000() throws Exception {
     assertFalse(prover.isUnsat());
   }
 
+  // test for ex quantifier inside formula
+  @Test
+  public void smt_s_split_09_000() throws Exception {
+    assume().that(solver).isNotEqualTo(Solvers.ELDARICA);
+    var prover = solveSmtLib2("s_split_09_000");
+
+    assertTrue(prover.isUnsat());
+  }
+
 
   // test for rewriting equation ITE terms and epsilon terms
   @Test
diff --git a/src/org/sosy_lab/java_smt/test/horn/s_split_09_000.license b/src/org/sosy_lab/java_smt/test/horn/s_split_09_000.license
new file mode 100644
index 0000000000..1abba28dd5
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/s_split_09_000.license
@@ -0,0 +1 @@
+SPDX-License-Identifier: Apache-2.0
diff --git a/src/org/sosy_lab/java_smt/test/horn/s_split_09_000.smt2 b/src/org/sosy_lab/java_smt/test/horn/s_split_09_000.smt2
new file mode 100644
index 0000000000..9d27604629
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/s_split_09_000.smt2
@@ -0,0 +1,40 @@
+(set-logic HORN)
+
+
+(declare-fun |inv| ( Int ) Bool)
+
+(assert
+  (forall ( (A Int) ) 
+    (=>
+      (and
+        (= A 0)
+      )
+      (inv A)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) ) 
+    (=>
+      (and
+        (inv B)
+        (= A (ite (= B 9998) 1 (+ 2 B)))
+      )
+      (inv A)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) ) 
+    (=>
+      (and
+        (inv A)
+        (and (not (<= A 9996)) (not (= 0 (mod A 4))))
+      )
+      false
+    )
+  )
+)
+
+(check-sat)
+(exit)

From 0ff8cd2e015e5281259d97fa69a5914a9b2d5563 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Tue, 21 Jul 2026 14:07:55 +0200
Subject: [PATCH 73/77] eldarica: fix crash when head is null

---
 .../princess/eldarica/PrincessHornConverter.java       | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
index f8a8cc0332..77fada7af2 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -50,6 +50,8 @@
 
 @SuppressWarnings({"unchecked", "PatternMatchingInstanceof"})
 public class PrincessHornConverter {
+  private static final IAtom FALSE = new IAtom(HornClauses.FALSE(),
+      (Seq<ITerm>) Seq$.MODULE$.empty());
   private final ArrayList<Predicate> predicates = new ArrayList<>();
 
   private Predicate toPredicate(final MonoSortedIFunction function) {
@@ -401,8 +403,10 @@ private IAtom toPredicateAtom(final IIntFormula formula) {
       return null;
     }
 
-    private Clause toClause(final IAtom head) {
-      assert head != null;
+    private Clause toClause(IAtom head) {
+      if(head == null) {
+        head = FALSE;
+      }
       return new Clause(head, List$.MODULE$.empty(), this.constraint);
     }
 
@@ -458,7 +462,7 @@ private Clause toClause(final IBinFormula input) {
           throw new RuntimeException("No head found: " + input);
         }
       } else {
-        head = new IAtom(HornClauses.FALSE(), (Seq<ITerm>) Seq$.MODULE$.empty());
+        head = FALSE;
         this.constraint = this.constraint.andSimplify(simplify(toFormula(other).notSimplify()));
 
         return toClause(head, simplify(not.subformula()));

From c58db087c907168041fb6a371ddea9e8937edbdb Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Tue, 21 Jul 2026 14:48:32 +0200
Subject: [PATCH 74/77] eldarica: various conversion fixes

Evaluation was bad :)
---
 .../eldarica/PrincessHornConverter.java       | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
index 77fada7af2..a616888e4d 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -186,13 +186,20 @@ private IAtom toFormula(final IAtom atom) {
       return new IAtom(atom.pred(), toTerm(atom.args()));
     }
 
+    private IFormula toFormulaITE(final ITerm term, final IFormula cond) {
+      return new IBinFormula(
+          IBinJunctor.Or(),
+          toFormula(cond),
+          new IIntFormula(IIntRelation.EqZero(), toTerm(term)));
+    }
+
     private IFormula toFormula(final IIntFormula i) {
       if (i.rel().equals(IIntRelation.EqZero()) && i.t() instanceof ITermITE ite) {
         if (ite.left() instanceof IIntLit lit && lit.value().isZero()) {
-          return toFormula(ite.cond());
+          return toFormulaITE(ite.right(), ite.cond());
         }
         if (ite.right() instanceof IIntLit lit && lit.value().isZero()) {
-          return toFormula(ite.cond().notSimplify());
+          return toFormulaITE(ite.left(), ite.cond().notSimplify());
         }
       }
       return new IIntFormula(i.rel(), toTerm(i.t()));
@@ -209,7 +216,7 @@ private IFormula toFormula(ITerm value, ITermITE ite) {
       var a = condition.andSimplify(new IEquation(value, left));
       var b = condition.notSimplify().andSimplify(new IEquation(value, right));
 
-      return a.andSimplify(b);
+      return a.orSimplify(b);
     }
 
     private IFormula toFormula(final IEquation equation) {
@@ -259,7 +266,7 @@ private IFormula toFormula(final IFormulaITE ite) {
       var b = condition.notSimplify().andSimplify(right);
 
 
-      return a.andSimplify(b);
+      return a.orSimplify(b);
     }
 
     private IFormula toFormula(final IFormula formula) {
@@ -347,7 +354,7 @@ private ITerm toTerm(final ITermITE ite) {
       var a = condition.andSimplify(new IEquation(variable, left));
       var b = condition.notSimplify().andSimplify(new IEquation(variable, right));
 
-      this.constraint = this.constraint.andSimplify(a.andSimplify(b));
+      this.constraint = this.constraint.andSimplify(a.orSimplify(b));
 
 
       return variable;
@@ -404,7 +411,7 @@ private IAtom toPredicateAtom(final IIntFormula formula) {
     }
 
     private Clause toClause(IAtom head) {
-      if(head == null) {
+      if (head == null) {
         head = FALSE;
       }
       return new Clause(head, List$.MODULE$.empty(), this.constraint);

From 8ea5da1fbd8c1df940f18bc3e69d81147f78510d Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Tue, 21 Jul 2026 14:49:00 +0200
Subject: [PATCH 75/77] more horn tests

They were all failing before the last commit.
---
 .../java_smt/test/horn/HornExampleTest.java   |   28 +-
 ...-unreach-call_true-termination_000.license |    1 +
 ...lse-unreach-call_true-termination_000.smt2 |   66 +
 .../java_smt/test/horn/s_split_37_000.license |    1 +
 .../java_smt/test/horn/s_split_37_000.smt2    |   40 +
 ...ht_negative_lvalue_int16.sol_2_000.license |    1 +
 ...right_negative_lvalue_int16.sol_2_000.smt2 | 2979 +++++++++++++++++
 7 files changed, 3112 insertions(+), 4 deletions(-)
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/O0_count_up_down_false-unreach-call_true-termination_000.license
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/O0_count_up_down_false-unreach-call_true-termination_000.smt2
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/s_split_37_000.license
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/s_split_37_000.smt2
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/shift_right_negative_lvalue_int16.sol_2_000.license
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/shift_right_negative_lvalue_int16.sol_2_000.smt2

diff --git a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
index 1e6e926cbb..56854673f7 100644
--- a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
+++ b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
@@ -173,8 +173,7 @@ public void smt_prusti_3_pass_paper_Examples_points_compress_000() throws Except
 
   @Test
   public void smt_38_c_000() throws Exception {
-    // TODO: enable when https://github.com/sosy-lab/java-smt/issues/682 is fixed
-    assume().that(solver).isNotEqualTo(Solvers.ELDARICA);
+    assume().that(solver).isNotEqualTo(Solvers.ELDARICA); // ex
     var prover = solveSmtLib2("38.c_000");
 
     assertFalse(prover.isUnsat());
@@ -193,8 +192,7 @@ public void smt_s_split_09_000() throws Exception {
   // test for rewriting equation ITE terms and epsilon terms
   @Test
   public void smt_s_split_18_000() throws Exception {
-    // TODO: enable when https://github.com/sosy-lab/java-smt/issues/682 is fixed
-    assume().that(solver).isNotEqualTo(Solvers.ELDARICA);
+    assume().that(solver).isNotEqualTo(Solvers.ELDARICA); // ex
     var prover = solveSmtLib2("s_split_18_000");
 
     assertFalse(prover.isUnsat());
@@ -222,6 +220,28 @@ public void smt_O0_fibo_10_false_unreach_call_000() throws Exception {
     assertTrue(prover.isUnsat());
   }
 
+
+  @Test
+  public void smt_O0_count_up_down_false_unreach_call_true_termination_000() throws Exception {
+    var prover = solveSmtLib2("O0_count_up_down_false-unreach-call_true-termination_000");
+
+    assertTrue(prover.isUnsat());
+  }
+
+  @Test
+  public void smt_shift_right_negative_lvalue_int16_sol_2_000() throws Exception {
+    var prover = solveSmtLib2("shift_right_negative_lvalue_int16.sol_2_000");
+
+    assertTrue(prover.isUnsat());
+  }
+
+  @Test
+  public void smt_s_split_37_000() throws Exception {
+    var prover = solveSmtLib2("s_split_37_000");
+
+    assertTrue(prover.isUnsat());
+  }
+
   @Test
   public void smt_small_unsat() throws Exception {
     /*
diff --git a/src/org/sosy_lab/java_smt/test/horn/O0_count_up_down_false-unreach-call_true-termination_000.license b/src/org/sosy_lab/java_smt/test/horn/O0_count_up_down_false-unreach-call_true-termination_000.license
new file mode 100644
index 0000000000..1abba28dd5
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/O0_count_up_down_false-unreach-call_true-termination_000.license
@@ -0,0 +1 @@
+SPDX-License-Identifier: Apache-2.0
diff --git a/src/org/sosy_lab/java_smt/test/horn/O0_count_up_down_false-unreach-call_true-termination_000.smt2 b/src/org/sosy_lab/java_smt/test/horn/O0_count_up_down_false-unreach-call_true-termination_000.smt2
new file mode 100644
index 0000000000..18e84d6d76
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/O0_count_up_down_false-unreach-call_true-termination_000.smt2
@@ -0,0 +1,66 @@
+(set-logic HORN)
+
+
+(declare-fun |f1| ( Int ) Bool)
+(declare-fun |f2| ( ) Bool)
+(declare-fun |f3| ( Int Int Int ) Bool)
+
+(assert
+  (forall ( (A Int) )
+    (=>
+        true
+      (f1 A)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Bool) (E Bool) (F Int) (G Int) (H Int) (I Int) )
+    (=>
+      (and
+        (f1 B)
+        (and (or (= C H))
+     (or (= F 0))
+     (or (not D) (and E D)))
+      )
+      (f3 G H I)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Bool) (C Bool) (D Int) (E Int) (F Bool) (G Bool) (H Bool) (I Bool) (J Int) (K Bool) (L Bool) (M Bool) (N Bool) (O Bool) )
+    (=>
+      (and
+        (f3 D E A)
+        (let ((a!1 (or (not H) (not (= (= D E) F)))))
+  (and (or C (not H) (not B))
+       a!1
+       (or (not H) (= J (ite F 1 0)))
+       (or (and H B))
+       (or (not G))
+       (or (= K (= J 0)))
+       (or (and L I))
+       (or (and M L))
+       (or (and N M))
+       (or (and O N))
+       (or K (not L))
+       (= O true)
+       (= C (= A 0))))
+      )
+      f2
+    )
+  )
+)
+(assert
+  (forall ( (CHC_COMP_UNUSED Bool) )
+    (=>
+      (and
+        f2
+        true
+      )
+      false
+    )
+  )
+)
+
+(check-sat)
+(exit)
diff --git a/src/org/sosy_lab/java_smt/test/horn/s_split_37_000.license b/src/org/sosy_lab/java_smt/test/horn/s_split_37_000.license
new file mode 100644
index 0000000000..1abba28dd5
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/s_split_37_000.license
@@ -0,0 +1 @@
+SPDX-License-Identifier: Apache-2.0
diff --git a/src/org/sosy_lab/java_smt/test/horn/s_split_37_000.smt2 b/src/org/sosy_lab/java_smt/test/horn/s_split_37_000.smt2
new file mode 100644
index 0000000000..3b9328e823
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/s_split_37_000.smt2
@@ -0,0 +1,40 @@
+(set-logic HORN)
+
+
+(declare-fun |inv| ( Int Int Int ) Bool)
+
+(assert
+  (forall ( (v_0 Int) (v_1 Int) (v_2 Int) ) 
+    (=>
+      (and
+        (and true (= 0 v_0) (= 0 v_1) (= 0 v_2))
+      )
+      (inv v_0 v_1 v_2)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) ) 
+    (=>
+      (and
+        (inv E F D)
+        (and (= B (ite (= E 0) 523 (+ F D))) (= A (ite (= E 0) D 250)) (= C (+ 1 E)))
+      )
+      (inv C B A)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) ) 
+    (=>
+      (and
+        (inv B A C)
+        (and (not (<= A 2500)) (>= B 10))
+      )
+      false
+    )
+  )
+)
+
+(check-sat)
+(exit)
diff --git a/src/org/sosy_lab/java_smt/test/horn/shift_right_negative_lvalue_int16.sol_2_000.license b/src/org/sosy_lab/java_smt/test/horn/shift_right_negative_lvalue_int16.sol_2_000.license
new file mode 100644
index 0000000000..1abba28dd5
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/shift_right_negative_lvalue_int16.sol_2_000.license
@@ -0,0 +1 @@
+SPDX-License-Identifier: Apache-2.0
diff --git a/src/org/sosy_lab/java_smt/test/horn/shift_right_negative_lvalue_int16.sol_2_000.smt2 b/src/org/sosy_lab/java_smt/test/horn/shift_right_negative_lvalue_int16.sol_2_000.smt2
new file mode 100644
index 0000000000..e5d5b072fe
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/shift_right_negative_lvalue_int16.sol_2_000.smt2
@@ -0,0 +1,2979 @@
+(set-logic HORN)
+
+(declare-datatypes ((state_type 0)) (((state_type  (balances (Array Int Int))))))
+(declare-datatypes ((abi_type 0)) (((abi_type ))))
+(declare-datatypes ((bytes_tuple 0)) (((bytes_tuple  (bytes_tuple_accessor_array (Array Int Int)) (bytes_tuple_accessor_length Int)))))
+(declare-datatypes ((ecrecover_input_type 0)) (((ecrecover_input_type  (hash Int) (v Int) (r Int) (s Int)))))
+(declare-datatypes ((crypto_type 0)) (((crypto_type  (ecrecover (Array ecrecover_input_type Int)) (keccak256 (Array bytes_tuple Int)) (ripemd160 (Array bytes_tuple Int)) (sha256 (Array bytes_tuple Int))))))
+(declare-datatypes ((tx_type 0)) (((tx_type  (block.basefee Int) (block.chainid Int) (block.coinbase Int) (block.difficulty Int) (block.gaslimit Int) (block.number Int) (block.timestamp Int) (blockhash (Array Int Int)) (msg.data bytes_tuple) (msg.sender Int) (msg.sig Int) (msg.value Int) (tx.gasprice Int) (tx.origin Int)))))
+
+(declare-fun |summary_3_function_f__14_149_0| ( Int Int abi_type crypto_type tx_type state_type Int Int state_type Int Int Int ) Bool)
+(declare-fun |block_10_function_t__148_149_0| ( Int Int abi_type crypto_type tx_type state_type state_type ) Bool)
+(declare-fun |summary_29_function_f__14_149_0| ( Int Int abi_type crypto_type tx_type state_type Int Int state_type Int Int Int ) Bool)
+(declare-fun |contract_initializer_entry_39_C_149_0| ( Int Int abi_type crypto_type tx_type state_type state_type ) Bool)
+(declare-fun |summary_35_function_f__14_149_0| ( Int Int abi_type crypto_type tx_type state_type Int Int state_type Int Int Int ) Bool)
+(declare-fun |block_12_return_function_t__148_149_0| ( Int Int abi_type crypto_type tx_type state_type state_type ) Bool)
+(declare-fun |contract_initializer_38_C_149_0| ( Int Int abi_type crypto_type tx_type state_type state_type ) Bool)
+(declare-fun |block_34_function_t__148_149_0| ( Int Int abi_type crypto_type tx_type state_type state_type ) Bool)
+(declare-fun |contract_initializer_after_init_40_C_149_0| ( Int Int abi_type crypto_type tx_type state_type state_type ) Bool)
+(declare-fun |block_18_function_t__148_149_0| ( Int Int abi_type crypto_type tx_type state_type state_type ) Bool)
+(declare-fun |summary_27_function_f__14_149_0| ( Int Int abi_type crypto_type tx_type state_type Int Int state_type Int Int Int ) Bool)
+(declare-fun |summary_15_function_f__14_149_0| ( Int Int abi_type crypto_type tx_type state_type Int Int state_type Int Int Int ) Bool)
+(declare-fun |block_28_function_t__148_149_0| ( Int Int abi_type crypto_type tx_type state_type state_type ) Bool)
+(declare-fun |block_37_function_t__148_149_0| ( Int Int abi_type crypto_type tx_type state_type state_type ) Bool)
+(declare-fun |summary_5_function_t__148_149_0| ( Int Int abi_type crypto_type tx_type state_type state_type ) Bool)
+(declare-fun |summary_constructor_2_C_149_0| ( Int Int abi_type crypto_type tx_type state_type state_type ) Bool)
+(declare-fun |block_20_function_t__148_149_0| ( Int Int abi_type crypto_type tx_type state_type state_type ) Bool)
+(declare-fun |summary_21_function_f__14_149_0| ( Int Int abi_type crypto_type tx_type state_type Int Int state_type Int Int Int ) Bool)
+(declare-fun |block_32_function_t__148_149_0| ( Int Int abi_type crypto_type tx_type state_type state_type ) Bool)
+(declare-fun |block_24_function_t__148_149_0| ( Int Int abi_type crypto_type tx_type state_type state_type ) Bool)
+(declare-fun |summary_31_function_f__14_149_0| ( Int Int abi_type crypto_type tx_type state_type Int Int state_type Int Int Int ) Bool)
+(declare-fun |block_30_function_t__148_149_0| ( Int Int abi_type crypto_type tx_type state_type state_type ) Bool)
+(declare-fun |block_11_t_147_149_0| ( Int Int abi_type crypto_type tx_type state_type state_type ) Bool)
+(declare-fun |summary_13_function_f__14_149_0| ( Int Int abi_type crypto_type tx_type state_type Int Int state_type Int Int Int ) Bool)
+(declare-fun |summary_25_function_f__14_149_0| ( Int Int abi_type crypto_type tx_type state_type Int Int state_type Int Int Int ) Bool)
+(declare-fun |error_target_19_0| ( ) Bool)
+(declare-fun |block_26_function_t__148_149_0| ( Int Int abi_type crypto_type tx_type state_type state_type ) Bool)
+(declare-fun |block_14_function_t__148_149_0| ( Int Int abi_type crypto_type tx_type state_type state_type ) Bool)
+(declare-fun |summary_33_function_f__14_149_0| ( Int Int abi_type crypto_type tx_type state_type Int Int state_type Int Int Int ) Bool)
+(declare-fun |implicit_constructor_entry_41_C_149_0| ( Int Int abi_type crypto_type tx_type state_type state_type ) Bool)
+(declare-fun |block_36_function_t__148_149_0| ( Int Int abi_type crypto_type tx_type state_type state_type ) Bool)
+(declare-fun |summary_4_function_t__148_149_0| ( Int Int abi_type crypto_type tx_type state_type state_type ) Bool)
+(declare-fun |summary_17_function_f__14_149_0| ( Int Int abi_type crypto_type tx_type state_type Int Int state_type Int Int Int ) Bool)
+(declare-fun |block_7_f_13_149_0| ( Int Int abi_type crypto_type tx_type state_type Int Int state_type Int Int Int ) Bool)
+(declare-fun |block_22_function_t__148_149_0| ( Int Int abi_type crypto_type tx_type state_type state_type ) Bool)
+(declare-fun |block_8_return_function_f__14_149_0| ( Int Int abi_type crypto_type tx_type state_type Int Int state_type Int Int Int ) Bool)
+(declare-fun |summary_23_function_f__14_149_0| ( Int Int abi_type crypto_type tx_type state_type Int Int state_type Int Int Int ) Bool)
+(declare-fun |block_16_function_t__148_149_0| ( Int Int abi_type crypto_type tx_type state_type state_type ) Bool)
+(declare-fun |interface_0_C_149_0| ( Int abi_type crypto_type state_type ) Bool)
+(declare-fun |block_6_function_f__14_149_0| ( Int Int abi_type crypto_type tx_type state_type Int Int state_type Int Int Int ) Bool)
+(declare-fun |summary_19_function_f__14_149_0| ( Int Int abi_type crypto_type tx_type state_type Int Int state_type Int Int Int ) Bool)
+
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D abi_type) (E Int) (F Int) (G crypto_type) (H Int) (I state_type) (J state_type) (K Int) (L tx_type) ) 
+    (=>
+      (and
+        true
+      )
+      (block_6_function_f__14_149_0 H K D G L I B E J C F A)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D abi_type) (E Int) (F Int) (G crypto_type) (H Int) (I state_type) (J state_type) (K Int) (L tx_type) ) 
+    (=>
+      (and
+        (block_6_function_f__14_149_0 H K D G L I B E J C F A)
+        (and (= H 0) (= C B) (= F E) (= J I))
+      )
+      (block_7_f_13_149_0 H K D G L I B E J C F A)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E abi_type) (F Int) (G Int) (H crypto_type) (I Int) (J Int) (K Int) (L Int) (M state_type) (N state_type) (O Int) (P tx_type) ) 
+    (=>
+      (and
+        (block_7_f_13_149_0 I O E H P M C F N D G A)
+        (let ((a!1 (ite (>= L 0)
+                ((_ int_to_bv 16) L)
+                (bvmul #xffff ((_ int_to_bv 16) (* (- 1) L)))))
+      (a!2 (ite (>= J 0)
+                ((_ int_to_bv 16) J)
+                (bvmul #xffff ((_ int_to_bv 16) (* (- 1) J))))))
+(let ((a!3 (* (- 1) (ubv_to_int (bvmul #xffff (bvashr a!1 a!2))))))
+(let ((a!4 (ite (= ((_ extract 15 15) (bvashr a!1 a!2)) #b0)
+                (ubv_to_int (bvashr a!1 a!2))
+                a!3)))
+  (and (= B K)
+       (= A 0)
+       (= K a!4)
+       (= J G)
+       (>= L (- 32768))
+       (>= G 0)
+       (>= D (- 32768))
+       (>= K (- 32768))
+       (>= J 0)
+       (<= L 32767)
+       (<= G 65535)
+       (<= D 32767)
+       (<= K 32767)
+       (<= J 65535)
+       (= L D)))))
+      )
+      (block_8_return_function_f__14_149_0 I O E H P M C F N D G B)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D abi_type) (E Int) (F Int) (G crypto_type) (H Int) (I state_type) (J state_type) (K Int) (L tx_type) ) 
+    (=>
+      (and
+        (block_8_return_function_f__14_149_0 H K D G L I B E J C F A)
+        true
+      )
+      (summary_3_function_f__14_149_0 H K D G L I B E J C F A)
+    )
+  )
+)
+(assert
+  (forall ( (A abi_type) (B crypto_type) (C Int) (D state_type) (E state_type) (F Int) (G tx_type) ) 
+    (=>
+      (and
+        true
+      )
+      (block_10_function_t__148_149_0 C F A B G D E)
+    )
+  )
+)
+(assert
+  (forall ( (A abi_type) (B crypto_type) (C Int) (D state_type) (E state_type) (F Int) (G tx_type) ) 
+    (=>
+      (and
+        (block_10_function_t__148_149_0 C F A B G D E)
+        (and (= C 0) (= E D))
+      )
+      (block_11_t_147_149_0 C F A B G D E)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D abi_type) (E Int) (F Int) (G crypto_type) (H Int) (I state_type) (J state_type) (K Int) (L tx_type) ) 
+    (=>
+      (and
+        (summary_3_function_f__14_149_0 H K D G L I B E J C F A)
+        true
+      )
+      (summary_13_function_f__14_149_0 H K D G L I B E J C F A)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C abi_type) (D Int) (E crypto_type) (F Int) (G Int) (H Int) (I Int) (J state_type) (K state_type) (L Int) (M tx_type) (v_13 state_type) ) 
+    (=>
+      (and
+        (block_11_t_147_149_0 F L C E M J K)
+        (summary_13_function_f__14_149_0 G L C E M K H I v_13 B D A)
+        (and (= v_13 K) (= H (- 4266)) (not (<= G 0)) (= I 0))
+      )
+      (summary_4_function_t__148_149_0 G L C E M J K)
+    )
+  )
+)
+(assert
+  (forall ( (A abi_type) (B crypto_type) (C Int) (D state_type) (E state_type) (F Int) (G tx_type) ) 
+    (=>
+      (and
+        (block_14_function_t__148_149_0 C F A B G D E)
+        true
+      )
+      (summary_4_function_t__148_149_0 C F A B G D E)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E abi_type) (F Int) (G Int) (H crypto_type) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) (Q Bool) (R Int) (S Int) (T state_type) (U state_type) (V Int) (W tx_type) (v_23 state_type) (v_24 state_type) ) 
+    (=>
+      (and
+        (block_11_t_147_149_0 I V E H W T U)
+        (summary_15_function_f__14_149_0 L V E H W U R S v_23 D G B)
+        (summary_13_function_f__14_149_0 J V E H W U M N v_24 C F A)
+        (and (= v_23 U)
+     (= v_24 U)
+     (= S 0)
+     (= M (- 4266))
+     (= P (- 4266))
+     (= O A)
+     (= N 0)
+     (= K J)
+     (= J 0)
+     (= R (- 4266))
+     (>= O
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (<= O
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (not (<= L 0))
+     (= Q (= O P)))
+      )
+      (summary_4_function_t__148_149_0 L V E H W T U)
+    )
+  )
+)
+(assert
+  (forall ( (A abi_type) (B crypto_type) (C Int) (D state_type) (E state_type) (F Int) (G tx_type) ) 
+    (=>
+      (and
+        (block_16_function_t__148_149_0 C F A B G D E)
+        true
+      )
+      (summary_4_function_t__148_149_0 C F A B G D E)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G abi_type) (H Int) (I Int) (J Int) (K crypto_type) (L Int) (M Int) (N Int) (O Int) (P Int) (Q Int) (R Int) (S Int) (T Int) (U Int) (V Bool) (W Int) (X Int) (Y Int) (Z Int) (A1 Bool) (B1 Int) (C1 Int) (D1 state_type) (E1 state_type) (F1 Int) (G1 tx_type) (v_33 state_type) (v_34 state_type) (v_35 state_type) ) 
+    (=>
+      (and
+        (block_11_t_147_149_0 L F1 G K G1 D1 E1)
+        (summary_17_function_f__14_149_0 Q F1 G K G1 E1 B1 C1 v_33 F J C)
+        (summary_13_function_f__14_149_0 M F1 G K G1 E1 R S v_34 D H A)
+        (summary_15_function_f__14_149_0 O F1 G K G1 E1 W X v_35 E I B)
+        (and (= v_33 E1)
+     (= v_34 E1)
+     (= v_35 E1)
+     (= V (= T U))
+     (= C1 1)
+     (= W (- 4266))
+     (= N M)
+     (= O 0)
+     (= M 0)
+     (= Z (- 426))
+     (= S 0)
+     (= R (- 4266))
+     (= P O)
+     (= Y B)
+     (= X 0)
+     (= U (- 4266))
+     (= T A)
+     (= B1 (- 4266))
+     (>= Y
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= T
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (not (<= Q 0))
+     (<= Y
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= T
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (= A1 (= Y Z)))
+      )
+      (summary_4_function_t__148_149_0 Q F1 G K G1 D1 E1)
+    )
+  )
+)
+(assert
+  (forall ( (A abi_type) (B crypto_type) (C Int) (D state_type) (E state_type) (F Int) (G tx_type) ) 
+    (=>
+      (and
+        (block_18_function_t__148_149_0 C F A B G D E)
+        true
+      )
+      (summary_4_function_t__148_149_0 C F A B G D E)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I abi_type) (J Int) (K Int) (L Int) (M Int) (N crypto_type) (O Int) (P Int) (Q Int) (R Int) (S Int) (T Int) (U Int) (V Int) (W Int) (X Int) (Y Int) (Z Int) (A1 Bool) (B1 Int) (C1 Int) (D1 Int) (E1 Int) (F1 Bool) (G1 Int) (H1 Int) (I1 Int) (J1 Int) (K1 Bool) (L1 Int) (M1 Int) (N1 state_type) (O1 state_type) (P1 Int) (Q1 tx_type) (v_43 state_type) (v_44 state_type) (v_45 state_type) (v_46 state_type) ) 
+    (=>
+      (and
+        (block_11_t_147_149_0 O P1 I N Q1 N1 O1)
+        (summary_19_function_f__14_149_0 V P1 I N Q1 O1 L1 M1 v_43 H M D)
+        (summary_13_function_f__14_149_0 P P1 I N Q1 O1 W X v_44 E J A)
+        (summary_17_function_f__14_149_0 T P1 I N Q1 O1 G1 H1 v_45 G L C)
+        (summary_15_function_f__14_149_0 R P1 I N Q1 O1 B1 C1 v_46 F K B)
+        (and (= v_43 O1)
+     (= v_44 O1)
+     (= v_45 O1)
+     (= v_46 O1)
+     (= A1 (= Y Z))
+     (= F1 (= D1 E1))
+     (= M1 1)
+     (= T 0)
+     (= S R)
+     (= Q P)
+     (= P 0)
+     (= G1 (- 4266))
+     (= U T)
+     (= X 0)
+     (= Y A)
+     (= R 0)
+     (= W (- 4266))
+     (= J1 (- 2133))
+     (= C1 0)
+     (= B1 (- 4266))
+     (= Z (- 4266))
+     (= I1 C)
+     (= H1 1)
+     (= E1 (- 426))
+     (= D1 B)
+     (= L1 (- 4266))
+     (>= Y
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= I1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= D1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (<= Y
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (not (<= V 0))
+     (<= I1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= D1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (= K1 (= I1 J1)))
+      )
+      (summary_4_function_t__148_149_0 V P1 I N Q1 N1 O1)
+    )
+  )
+)
+(assert
+  (forall ( (A abi_type) (B crypto_type) (C Int) (D state_type) (E state_type) (F Int) (G tx_type) ) 
+    (=>
+      (and
+        (block_20_function_t__148_149_0 C F A B G D E)
+        true
+      )
+      (summary_4_function_t__148_149_0 C F A B G D E)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K abi_type) (L Int) (M Int) (N Int) (O Int) (P Int) (Q crypto_type) (R Int) (S Int) (T Int) (U Int) (V Int) (W Int) (X Int) (Y Int) (Z Int) (A1 Int) (B1 Int) (C1 Int) (D1 Int) (E1 Int) (F1 Bool) (G1 Int) (H1 Int) (I1 Int) (J1 Int) (K1 Bool) (L1 Int) (M1 Int) (N1 Int) (O1 Int) (P1 Bool) (Q1 Int) (R1 Int) (S1 Int) (T1 Int) (U1 Bool) (V1 Int) (W1 Int) (X1 state_type) (Y1 state_type) (Z1 Int) (A2 tx_type) (v_53 state_type) (v_54 state_type) (v_55 state_type) (v_56 state_type) (v_57 state_type) ) 
+    (=>
+      (and
+        (block_11_t_147_149_0 R Z1 K Q A2 X1 Y1)
+        (summary_21_function_f__14_149_0 A1 Z1 K Q A2 Y1 V1 W1 v_53 J P E)
+        (summary_13_function_f__14_149_0 S Z1 K Q A2 Y1 B1 C1 v_54 F L A)
+        (summary_19_function_f__14_149_0 Y Z1 K Q A2 Y1 Q1 R1 v_55 I O D)
+        (summary_17_function_f__14_149_0 W Z1 K Q A2 Y1 L1 M1 v_56 H N C)
+        (summary_15_function_f__14_149_0 U Z1 K Q A2 Y1 G1 H1 v_57 G M B)
+        (and (= v_53 Y1)
+     (= v_54 Y1)
+     (= v_55 Y1)
+     (= v_56 Y1)
+     (= v_57 Y1)
+     (= U1 (= S1 T1))
+     (= K1 (= I1 J1))
+     (= P1 (= N1 O1))
+     (= W1 4)
+     (= T S)
+     (= Y 0)
+     (= U 0)
+     (= D1 A)
+     (= S 0)
+     (= V U)
+     (= C1 0)
+     (= Z Y)
+     (= Q1 (- 4266))
+     (= X W)
+     (= E1 (- 4266))
+     (= W 0)
+     (= H1 0)
+     (= I1 B)
+     (= B1 (- 4266))
+     (= G1 (- 4266))
+     (= T1 (- 21330))
+     (= M1 1)
+     (= L1 (- 4266))
+     (= J1 (- 426))
+     (= S1 D)
+     (= R1 1)
+     (= O1 (- 2133))
+     (= N1 C)
+     (= V1 (- 4266))
+     (>= D1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= I1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= S1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= N1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (<= D1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (not (<= A1 0))
+     (<= I1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= S1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= N1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (= F1 (= D1 E1)))
+      )
+      (summary_4_function_t__148_149_0 A1 Z1 K Q A2 X1 Y1)
+    )
+  )
+)
+(assert
+  (forall ( (A abi_type) (B crypto_type) (C Int) (D state_type) (E state_type) (F Int) (G tx_type) ) 
+    (=>
+      (and
+        (block_22_function_t__148_149_0 C F A B G D E)
+        true
+      )
+      (summary_4_function_t__148_149_0 C F A B G D E)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M abi_type) (N Int) (O Int) (P Int) (Q Int) (R Int) (S Int) (T crypto_type) (U Int) (V Int) (W Int) (X Int) (Y Int) (Z Int) (A1 Int) (B1 Int) (C1 Int) (D1 Int) (E1 Int) (F1 Int) (G1 Int) (H1 Int) (I1 Int) (J1 Int) (K1 Bool) (L1 Int) (M1 Int) (N1 Int) (O1 Int) (P1 Bool) (Q1 Int) (R1 Int) (S1 Int) (T1 Int) (U1 Bool) (V1 Int) (W1 Int) (X1 Int) (Y1 Int) (Z1 Bool) (A2 Int) (B2 Int) (C2 Int) (D2 Int) (E2 Bool) (F2 Int) (G2 Int) (H2 state_type) (I2 state_type) (J2 Int) (K2 tx_type) (v_63 state_type) (v_64 state_type) (v_65 state_type) (v_66 state_type) (v_67 state_type) (v_68 state_type) ) 
+    (=>
+      (and
+        (block_11_t_147_149_0 U J2 M T K2 H2 I2)
+        (summary_23_function_f__14_149_0 X J2 M T K2 I2 F2 G2 v_63 L S F)
+        (summary_13_function_f__14_149_0 V J2 M T K2 I2 G1 H1 v_64 G N A)
+        (summary_21_function_f__14_149_0 F1 J2 M T K2 I2 A2 B2 v_65 K R E)
+        (summary_19_function_f__14_149_0 D1 J2 M T K2 I2 V1 W1 v_66 J Q D)
+        (summary_17_function_f__14_149_0 B1 J2 M T K2 I2 Q1 R1 v_67 I P C)
+        (summary_15_function_f__14_149_0 Z J2 M T K2 I2 L1 M1 v_68 H O B)
+        (and (= v_63 I2)
+     (= v_64 I2)
+     (= v_65 I2)
+     (= v_66 I2)
+     (= v_67 I2)
+     (= v_68 I2)
+     (= E2 (= C2 D2))
+     (= U1 (= S1 T1))
+     (= K1 (= I1 J1))
+     (= Z1 (= X1 Y1))
+     (= G2 4)
+     (= D1 0)
+     (= Z 0)
+     (= I1 A)
+     (= E1 D1)
+     (= V 0)
+     (= W F1)
+     (= Y V)
+     (= N1 B)
+     (= A1 Z)
+     (= C1 B1)
+     (= F1 0)
+     (= B1 0)
+     (= M1 0)
+     (= J1 (- 4266))
+     (= A2 (- 4266))
+     (= H1 0)
+     (= O1 (- 426))
+     (= G1 (- 4266))
+     (= R1 1)
+     (= S1 C)
+     (= L1 (- 4266))
+     (= Q1 (- 4266))
+     (= D2 (- 267))
+     (= W1 1)
+     (= V1 (- 4266))
+     (= T1 (- 2133))
+     (= C2 E)
+     (= B2 4)
+     (= Y1 (- 21330))
+     (= X1 D)
+     (= F2 (- 4266))
+     (>= I1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= N1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= S1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= C2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= X1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (<= I1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= N1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (not (<= X 0))
+     (<= S1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= C2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= X1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (= P1 (= N1 O1)))
+      )
+      (summary_4_function_t__148_149_0 X J2 M T K2 H2 I2)
+    )
+  )
+)
+(assert
+  (forall ( (A abi_type) (B crypto_type) (C Int) (D state_type) (E state_type) (F Int) (G tx_type) ) 
+    (=>
+      (and
+        (block_24_function_t__148_149_0 C F A B G D E)
+        true
+      )
+      (summary_4_function_t__148_149_0 C F A B G D E)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O abi_type) (P Int) (Q Int) (R Int) (S Int) (T Int) (U Int) (V Int) (W crypto_type) (X Int) (Y Int) (Z Int) (A1 Int) (B1 Int) (C1 Int) (D1 Int) (E1 Int) (F1 Int) (G1 Int) (H1 Int) (I1 Int) (J1 Int) (K1 Int) (L1 Int) (M1 Int) (N1 Int) (O1 Int) (P1 Bool) (Q1 Int) (R1 Int) (S1 Int) (T1 Int) (U1 Bool) (V1 Int) (W1 Int) (X1 Int) (Y1 Int) (Z1 Bool) (A2 Int) (B2 Int) (C2 Int) (D2 Int) (E2 Bool) (F2 Int) (G2 Int) (H2 Int) (I2 Int) (J2 Bool) (K2 Int) (L2 Int) (M2 Int) (N2 Int) (O2 Bool) (P2 Int) (Q2 Int) (R2 state_type) (S2 state_type) (T2 Int) (U2 tx_type) (v_73 state_type) (v_74 state_type) (v_75 state_type) (v_76 state_type) (v_77 state_type) (v_78 state_type) (v_79 state_type) ) 
+    (=>
+      (and
+        (block_11_t_147_149_0 X T2 O W U2 R2 S2)
+        (summary_25_function_f__14_149_0 C1 T2 O W U2 S2 P2 Q2 v_73 N V G)
+        (summary_13_function_f__14_149_0 Y T2 O W U2 S2 L1 M1 v_74 H P A)
+        (summary_23_function_f__14_149_0 A1 T2 O W U2 S2 K2 L2 v_75 M U F)
+        (summary_21_function_f__14_149_0 K1 T2 O W U2 S2 F2 G2 v_76 L T E)
+        (summary_19_function_f__14_149_0 I1 T2 O W U2 S2 A2 B2 v_77 K S D)
+        (summary_15_function_f__14_149_0 E1 T2 O W U2 S2 Q1 R1 v_78 I Q B)
+        (summary_17_function_f__14_149_0 G1 T2 O W U2 S2 V1 W1 v_79 J R C)
+        (and (= v_73 S2)
+     (= v_74 S2)
+     (= v_75 S2)
+     (= v_76 S2)
+     (= v_77 S2)
+     (= v_78 S2)
+     (= v_79 S2)
+     (= Z1 (= X1 Y1))
+     (= O2 (= M2 N2))
+     (= E2 (= C2 D2))
+     (= U1 (= S1 T1))
+     (= J2 (= H2 I2))
+     (= Q2 8)
+     (= A1 0)
+     (= E1 0)
+     (= Z K1)
+     (= Y 0)
+     (= N1 A)
+     (= J1 I1)
+     (= D1 Y)
+     (= B1 A1)
+     (= S1 B)
+     (= O1 (- 4266))
+     (= F1 E1)
+     (= G1 0)
+     (= I1 0)
+     (= X1 C)
+     (= H1 G1)
+     (= K1 0)
+     (= M1 0)
+     (= L1 (- 4266))
+     (= W1 1)
+     (= T1 (- 426))
+     (= K2 (- 4266))
+     (= R1 0)
+     (= Y1 (- 2133))
+     (= Q1 (- 4266))
+     (= B2 1)
+     (= C2 D)
+     (= V1 (- 4266))
+     (= A2 (- 4266))
+     (= N2 (- 255))
+     (= G2 4)
+     (= F2 (- 4266))
+     (= D2 (- 21330))
+     (= M2 F)
+     (= L2 4)
+     (= I2 (- 267))
+     (= H2 E)
+     (= P2 (- 4266))
+     (>= N1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= S1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= X1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= C2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= M2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= H2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (<= N1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (not (<= C1 0))
+     (<= S1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= X1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= C2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= M2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= H2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (= P1 (= N1 O1)))
+      )
+      (summary_4_function_t__148_149_0 C1 T2 O W U2 R2 S2)
+    )
+  )
+)
+(assert
+  (forall ( (A abi_type) (B crypto_type) (C Int) (D state_type) (E state_type) (F Int) (G tx_type) ) 
+    (=>
+      (and
+        (block_26_function_t__148_149_0 C F A B G D E)
+        true
+      )
+      (summary_4_function_t__148_149_0 C F A B G D E)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) (Q abi_type) (R Int) (S Int) (T Int) (U Int) (V Int) (W Int) (X Int) (Y Int) (Z crypto_type) (A1 Int) (B1 Int) (C1 Int) (D1 Int) (E1 Int) (F1 Int) (G1 Int) (H1 Int) (I1 Int) (J1 Int) (K1 Int) (L1 Int) (M1 Int) (N1 Int) (O1 Int) (P1 Int) (Q1 Int) (R1 Int) (S1 Int) (T1 Int) (U1 Bool) (V1 Int) (W1 Int) (X1 Int) (Y1 Int) (Z1 Bool) (A2 Int) (B2 Int) (C2 Int) (D2 Int) (E2 Bool) (F2 Int) (G2 Int) (H2 Int) (I2 Int) (J2 Bool) (K2 Int) (L2 Int) (M2 Int) (N2 Int) (O2 Bool) (P2 Int) (Q2 Int) (R2 Int) (S2 Int) (T2 Bool) (U2 Int) (V2 Int) (W2 Int) (X2 Int) (Y2 Bool) (Z2 Int) (A3 Int) (B3 state_type) (C3 state_type) (D3 Int) (E3 tx_type) (v_83 state_type) (v_84 state_type) (v_85 state_type) (v_86 state_type) (v_87 state_type) (v_88 state_type) (v_89 state_type) (v_90 state_type) ) 
+    (=>
+      (and
+        (block_11_t_147_149_0 A1 D3 Q Z E3 B3 C3)
+        (summary_27_function_f__14_149_0 H1 D3 Q Z E3 C3 Z2 A3 v_83 P Y H)
+        (summary_13_function_f__14_149_0 B1 D3 Q Z E3 C3 Q1 R1 v_84 I R A)
+        (summary_25_function_f__14_149_0 F1 D3 Q Z E3 C3 U2 V2 v_85 O X G)
+        (summary_23_function_f__14_149_0 D1 D3 Q Z E3 C3 P2 Q2 v_86 N W F)
+        (summary_21_function_f__14_149_0 P1 D3 Q Z E3 C3 K2 L2 v_87 M V E)
+        (summary_15_function_f__14_149_0 J1 D3 Q Z E3 C3 V1 W1 v_88 J S B)
+        (summary_19_function_f__14_149_0 N1 D3 Q Z E3 C3 F2 G2 v_89 L U D)
+        (summary_17_function_f__14_149_0 L1 D3 Q Z E3 C3 A2 B2 v_90 K T C)
+        (and (= v_83 C3)
+     (= v_84 C3)
+     (= v_85 C3)
+     (= v_86 C3)
+     (= v_87 C3)
+     (= v_88 C3)
+     (= v_89 C3)
+     (= v_90 C3)
+     (= Z1 (= X1 Y1))
+     (= J2 (= H2 I2))
+     (= Y2 (= W2 X2))
+     (= O2 (= M2 N2))
+     (= E2 (= C2 D2))
+     (= T2 (= R2 S2))
+     (= A3 8)
+     (= K1 J1)
+     (= E1 D1)
+     (= D1 0)
+     (= C1 P1)
+     (= B1 0)
+     (= F1 0)
+     (= O1 N1)
+     (= G1 F1)
+     (= J1 0)
+     (= I1 B1)
+     (= X1 B)
+     (= T1 (- 4266))
+     (= N1 0)
+     (= M1 L1)
+     (= L1 0)
+     (= C2 C)
+     (= Y1 (- 426))
+     (= P1 0)
+     (= Q1 (- 4266))
+     (= S1 A)
+     (= H2 D)
+     (= R1 0)
+     (= W1 0)
+     (= V1 (- 4266))
+     (= G2 1)
+     (= D2 (- 2133))
+     (= U2 (- 4266))
+     (= B2 1)
+     (= I2 (- 21330))
+     (= A2 (- 4266))
+     (= L2 4)
+     (= M2 E)
+     (= F2 (- 4266))
+     (= K2 (- 4266))
+     (= X2 (- 17))
+     (= Q2 4)
+     (= P2 (- 4266))
+     (= N2 (- 267))
+     (= W2 G)
+     (= V2 8)
+     (= S2 (- 255))
+     (= R2 F)
+     (= Z2 (- 4266))
+     (>= X1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= C2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= S1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= H2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= M2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= W2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= R2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (not (<= H1 0))
+     (<= X1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= C2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= S1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= H2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= M2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= W2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= R2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (= U1 (= S1 T1)))
+      )
+      (summary_4_function_t__148_149_0 H1 D3 Q Z E3 B3 C3)
+    )
+  )
+)
+(assert
+  (forall ( (A abi_type) (B crypto_type) (C Int) (D state_type) (E state_type) (F Int) (G tx_type) ) 
+    (=>
+      (and
+        (block_28_function_t__148_149_0 C F A B G D E)
+        true
+      )
+      (summary_4_function_t__148_149_0 C F A B G D E)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) (Q Int) (R Int) (S abi_type) (T Int) (U Int) (V Int) (W Int) (X Int) (Y Int) (Z Int) (A1 Int) (B1 Int) (C1 crypto_type) (D1 Int) (E1 Int) (F1 Int) (G1 Int) (H1 Int) (I1 Int) (J1 Int) (K1 Int) (L1 Int) (M1 Int) (N1 Int) (O1 Int) (P1 Int) (Q1 Int) (R1 Int) (S1 Int) (T1 Int) (U1 Int) (V1 Int) (W1 Bool) (X1 Int) (Y1 Int) (Z1 Int) (A2 Int) (B2 Int) (C2 Int) (D2 Bool) (E2 Int) (F2 Int) (G2 Int) (H2 Int) (I2 Bool) (J2 Int) (K2 Int) (L2 Int) (M2 Int) (N2 Bool) (O2 Int) (P2 Int) (Q2 Int) (R2 Int) (S2 Bool) (T2 Int) (U2 Int) (V2 Int) (W2 Int) (X2 Bool) (Y2 Int) (Z2 Int) (A3 Int) (B3 Int) (C3 Bool) (D3 Int) (E3 Int) (F3 Int) (G3 Int) (H3 Bool) (I3 Int) (J3 Int) (K3 Int) (L3 state_type) (M3 state_type) (N3 Int) (O3 tx_type) (v_93 state_type) (v_94 state_type) (v_95 state_type) (v_96 state_type) (v_97 state_type) (v_98 state_type) (v_99 state_type) (v_100 state_type) (v_101 state_type) ) 
+    (=>
+      (and
+        (block_11_t_147_149_0 D1 N3 S C1 O3 L3 M3)
+        (summary_29_function_f__14_149_0 M1 N3 S C1 O3 M3 X1 Y1 v_93 J T A)
+        (summary_13_function_f__14_149_0 E1 N3 S C1 O3 M3 Z1 A2 v_94 K U B)
+        (summary_27_function_f__14_149_0 K1 N3 S C1 O3 M3 I3 J3 v_95 R B1 I)
+        (summary_25_function_f__14_149_0 I1 N3 S C1 O3 M3 D3 E3 v_96 Q A1 H)
+        (summary_23_function_f__14_149_0 G1 N3 S C1 O3 M3 Y2 Z2 v_97 P Z G)
+        (summary_15_function_f__14_149_0 O1 N3 S C1 O3 M3 E2 F2 v_98 L V C)
+        (summary_21_function_f__14_149_0 U1 N3 S C1 O3 M3 T2 U2 v_99 O Y F)
+        (summary_19_function_f__14_149_0 S1 N3 S C1 O3 M3 O2 P2 v_100 N X E)
+        (summary_17_function_f__14_149_0 Q1 N3 S C1 O3 M3 J2 K2 v_101 M W D)
+        (and (= v_93 M3)
+     (= v_94 M3)
+     (= v_95 M3)
+     (= v_96 M3)
+     (= v_97 M3)
+     (= v_98 M3)
+     (= v_99 M3)
+     (= v_100 M3)
+     (= v_101 M3)
+     (= D2 (= B2 C2))
+     (= I2 (= G2 H2))
+     (= N2 (= L2 M2))
+     (= S2 (= Q2 R2))
+     (= X2 (= V2 W2))
+     (= C3 (= A3 B3))
+     (= H3 (= F3 G3))
+     (= K3 I)
+     (= E1 0)
+     (= K1 0)
+     (= J1 I1)
+     (= F1 U1)
+     (= G1 0)
+     (= H1 G1)
+     (= I1 0)
+     (= U1 0)
+     (= O1 0)
+     (= N1 E1)
+     (= L1 K1)
+     (= P1 O1)
+     (= Y1 16)
+     (= Q1 0)
+     (= T1 S1)
+     (= S1 0)
+     (= R1 Q1)
+     (= H2 (- 426))
+     (= X1 (- 4266))
+     (= V1 (- 1))
+     (= M2 (- 2133))
+     (= Z1 (- 4266))
+     (= A2 0)
+     (= C2 (- 4266))
+     (= R2 (- 21330))
+     (= B2 B)
+     (= E2 (- 4266))
+     (= G2 C)
+     (= J2 (- 4266))
+     (= F2 0)
+     (= Q2 E)
+     (= O2 (- 4266))
+     (= E3 8)
+     (= L2 D)
+     (= K2 1)
+     (= V2 F)
+     (= W2 (- 267))
+     (= P2 1)
+     (= U2 4)
+     (= T2 (- 4266))
+     (= A3 G)
+     (= Z2 4)
+     (= Y2 (- 4266))
+     (= G3 (- 17))
+     (= F3 H)
+     (= D3 (- 4266))
+     (= B3 (- 255))
+     (= J3 8)
+     (= I3 (- 4266))
+     (>= K3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= B2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= G2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= Q2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= L2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= V2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= A3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= F3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (<= K3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (not (<= M1 0))
+     (<= B2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= G2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= Q2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= L2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= V2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= A3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= F3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (= W1 (= K3 V1)))
+      )
+      (summary_4_function_t__148_149_0 M1 N3 S C1 O3 L3 M3)
+    )
+  )
+)
+(assert
+  (forall ( (A abi_type) (B crypto_type) (C Int) (D state_type) (E state_type) (F Int) (G tx_type) ) 
+    (=>
+      (and
+        (block_30_function_t__148_149_0 C F A B G D E)
+        true
+      )
+      (summary_4_function_t__148_149_0 C F A B G D E)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) (Q Int) (R Int) (S Int) (T Int) (U abi_type) (V Int) (W Int) (X Int) (Y Int) (Z Int) (A1 Int) (B1 Int) (C1 Int) (D1 Int) (E1 Int) (F1 crypto_type) (G1 Int) (H1 Int) (I1 Int) (J1 Int) (K1 Int) (L1 Int) (M1 Int) (N1 Int) (O1 Int) (P1 Int) (Q1 Int) (R1 Int) (S1 Int) (T1 Int) (U1 Int) (V1 Int) (W1 Int) (X1 Int) (Y1 Int) (Z1 Int) (A2 Int) (B2 Bool) (C2 Int) (D2 Int) (E2 Int) (F2 Int) (G2 Bool) (H2 Int) (I2 Int) (J2 Int) (K2 Int) (L2 Int) (M2 Int) (N2 Bool) (O2 Int) (P2 Int) (Q2 Int) (R2 Int) (S2 Bool) (T2 Int) (U2 Int) (V2 Int) (W2 Int) (X2 Bool) (Y2 Int) (Z2 Int) (A3 Int) (B3 Int) (C3 Bool) (D3 Int) (E3 Int) (F3 Int) (G3 Int) (H3 Bool) (I3 Int) (J3 Int) (K3 Int) (L3 Int) (M3 Bool) (N3 Int) (O3 Int) (P3 Int) (Q3 Int) (R3 Bool) (S3 Int) (T3 Int) (U3 Int) (V3 state_type) (W3 state_type) (X3 Int) (Y3 tx_type) (v_103 state_type) (v_104 state_type) (v_105 state_type) (v_106 state_type) (v_107 state_type) (v_108 state_type) (v_109 state_type) (v_110 state_type) (v_111 state_type) (v_112 state_type) ) 
+    (=>
+      (and
+        (block_11_t_147_149_0 G1 X3 U F1 Y3 V3 W3)
+        (summary_31_function_f__14_149_0 R1 X3 U F1 Y3 W3 H2 I2 v_103 L W B)
+        (summary_13_function_f__14_149_0 H1 X3 U F1 Y3 W3 J2 K2 v_104 M X C)
+        (summary_29_function_f__14_149_0 P1 X3 U F1 Y3 W3 C2 D2 v_105 K V A)
+        (summary_27_function_f__14_149_0 N1 X3 U F1 Y3 W3 S3 T3 v_106 T E1 J)
+        (summary_25_function_f__14_149_0 L1 X3 U F1 Y3 W3 N3 O3 v_107 S D1 I)
+        (summary_15_function_f__14_149_0 T1 X3 U F1 Y3 W3 O2 P2 v_108 N Y D)
+        (summary_23_function_f__14_149_0 J1 X3 U F1 Y3 W3 I3 J3 v_109 R C1 H)
+        (summary_21_function_f__14_149_0 Z1 X3 U F1 Y3 W3 D3 E3 v_110 Q B1 G)
+        (summary_19_function_f__14_149_0 X1 X3 U F1 Y3 W3 Y2 Z2 v_111 P A1 F)
+        (summary_17_function_f__14_149_0 V1 X3 U F1 Y3 W3 T2 U2 v_112 O Z E)
+        (and (= v_103 W3)
+     (= v_104 W3)
+     (= v_105 W3)
+     (= v_106 W3)
+     (= v_107 W3)
+     (= v_108 W3)
+     (= v_109 W3)
+     (= v_110 W3)
+     (= v_111 W3)
+     (= v_112 W3)
+     (= B2 (= U3 A2))
+     (= N2 (= L2 M2))
+     (= S2 (= Q2 R2))
+     (= X2 (= V2 W2))
+     (= C3 (= A3 B3))
+     (= H3 (= F3 G3))
+     (= M3 (= K3 L3))
+     (= R3 (= P3 Q3))
+     (= U3 J)
+     (= K1 J1)
+     (= H1 0)
+     (= I1 Z1)
+     (= J1 0)
+     (= O1 N1)
+     (= N1 0)
+     (= M1 L1)
+     (= L1 0)
+     (= U1 T1)
+     (= T1 0)
+     (= P1 0)
+     (= Q1 P1)
+     (= S1 H1)
+     (= E2 A)
+     (= Y1 X1)
+     (= X1 0)
+     (= W1 V1)
+     (= V1 0)
+     (= Z1 0)
+     (= I2 16)
+     (= A2 (- 1))
+     (= D2 16)
+     (= C2 (- 4266))
+     (= R2 (- 426))
+     (= H2 (- 4266))
+     (= F2 (- 1))
+     (= W2 (- 2133))
+     (= J2 (- 4266))
+     (= K2 0)
+     (= M2 (- 4266))
+     (= B3 (- 21330))
+     (= L2 C)
+     (= O2 (- 4266))
+     (= Q2 D)
+     (= T2 (- 4266))
+     (= P2 0)
+     (= A3 F)
+     (= Y2 (- 4266))
+     (= O3 8)
+     (= V2 E)
+     (= U2 1)
+     (= F3 G)
+     (= G3 (- 267))
+     (= Z2 1)
+     (= E3 4)
+     (= D3 (- 4266))
+     (= K3 H)
+     (= J3 4)
+     (= I3 (- 4266))
+     (= Q3 (- 17))
+     (= P3 I)
+     (= N3 (- 4266))
+     (= L3 (- 255))
+     (= T3 8)
+     (= S3 (- 4266))
+     (>= U3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= E2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= L2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= Q2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= A3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= V2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= F3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= K3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= P3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (<= U3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (not (<= R1 0))
+     (<= E2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= L2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= Q2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= A3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= V2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= F3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= K3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= P3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (= G2 (= E2 F2)))
+      )
+      (summary_4_function_t__148_149_0 R1 X3 U F1 Y3 V3 W3)
+    )
+  )
+)
+(assert
+  (forall ( (A abi_type) (B crypto_type) (C Int) (D state_type) (E state_type) (F Int) (G tx_type) ) 
+    (=>
+      (and
+        (block_32_function_t__148_149_0 C F A B G D E)
+        true
+      )
+      (summary_4_function_t__148_149_0 C F A B G D E)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) (Q Int) (R Int) (S Int) (T Int) (U Int) (V Int) (W abi_type) (X Int) (Y Int) (Z Int) (A1 Int) (B1 Int) (C1 Int) (D1 Int) (E1 Int) (F1 Int) (G1 Int) (H1 Int) (I1 crypto_type) (J1 Int) (K1 Int) (L1 Int) (M1 Int) (N1 Int) (O1 Int) (P1 Int) (Q1 Int) (R1 Int) (S1 Int) (T1 Int) (U1 Int) (V1 Int) (W1 Int) (X1 Int) (Y1 Int) (Z1 Int) (A2 Int) (B2 Int) (C2 Int) (D2 Int) (E2 Int) (F2 Int) (G2 Bool) (H2 Int) (I2 Int) (J2 Int) (K2 Int) (L2 Bool) (M2 Int) (N2 Int) (O2 Int) (P2 Int) (Q2 Bool) (R2 Int) (S2 Int) (T2 Int) (U2 Int) (V2 Int) (W2 Int) (X2 Bool) (Y2 Int) (Z2 Int) (A3 Int) (B3 Int) (C3 Bool) (D3 Int) (E3 Int) (F3 Int) (G3 Int) (H3 Bool) (I3 Int) (J3 Int) (K3 Int) (L3 Int) (M3 Bool) (N3 Int) (O3 Int) (P3 Int) (Q3 Int) (R3 Bool) (S3 Int) (T3 Int) (U3 Int) (V3 Int) (W3 Bool) (X3 Int) (Y3 Int) (Z3 Int) (A4 Int) (B4 Bool) (C4 Int) (D4 Int) (E4 Int) (F4 state_type) (G4 state_type) (H4 Int) (I4 tx_type) (v_113 state_type) (v_114 state_type) (v_115 state_type) (v_116 state_type) (v_117 state_type) (v_118 state_type) (v_119 state_type) (v_120 state_type) (v_121 state_type) (v_122 state_type) (v_123 state_type) ) 
+    (=>
+      (and
+        (block_11_t_147_149_0 J1 H4 W I1 I4 F4 G4)
+        (summary_33_function_f__14_149_0 X1 H4 W I1 I4 G4 R2 S2 v_113 N Z C)
+        (summary_13_function_f__14_149_0 K1 H4 W I1 I4 G4 T2 U2 v_114 O A1 D)
+        (summary_31_function_f__14_149_0 U1 H4 W I1 I4 G4 M2 N2 v_115 M Y B)
+        (summary_29_function_f__14_149_0 S1 H4 W I1 I4 G4 H2 I2 v_116 L X A)
+        (summary_27_function_f__14_149_0 Q1 H4 W I1 I4 G4 C4 D4 v_117 V H1 K)
+        (summary_15_function_f__14_149_0 Y1 H4 W I1 I4 G4 Y2 Z2 v_118 P B1 E)
+        (summary_25_function_f__14_149_0 O1 H4 W I1 I4 G4 X3 Y3 v_119 U G1 J)
+        (summary_23_function_f__14_149_0 M1 H4 W I1 I4 G4 S3 T3 v_120 T F1 I)
+        (summary_21_function_f__14_149_0 E2 H4 W I1 I4 G4 N3 O3 v_121 S E1 H)
+        (summary_17_function_f__14_149_0 A2 H4 W I1 I4 G4 D3 E3 v_122 Q C1 F)
+        (summary_19_function_f__14_149_0 C2 H4 W I1 I4 G4 I3 J3 v_123 R D1 G)
+        (and (= v_113 G4)
+     (= v_114 G4)
+     (= v_115 G4)
+     (= v_116 G4)
+     (= v_117 G4)
+     (= v_118 G4)
+     (= v_119 G4)
+     (= v_120 G4)
+     (= v_121 G4)
+     (= v_122 G4)
+     (= v_123 G4)
+     (= G2 (= E4 F2))
+     (= L2 (= J2 K2))
+     (= X2 (= V2 W2))
+     (= C3 (= A3 B3))
+     (= H3 (= F3 G3))
+     (= M3 (= K3 L3))
+     (= R3 (= P3 Q3))
+     (= W3 (= U3 V3))
+     (= B4 (= Z3 A4))
+     (= E4 K)
+     (= K1 0)
+     (= O1 0)
+     (= N1 M1)
+     (= M1 0)
+     (= L1 E2)
+     (= U1 0)
+     (= P1 O1)
+     (= Q1 0)
+     (= R1 Q1)
+     (= S1 0)
+     (= T1 S1)
+     (= Y1 0)
+     (= W1 U1)
+     (= V1 K1)
+     (= E2 0)
+     (= D2 C2)
+     (= Z1 Y1)
+     (= A2 0)
+     (= B2 A2)
+     (= C2 0)
+     (= O2 B)
+     (= I2 16)
+     (= H2 (- 4266))
+     (= F2 (- 1))
+     (= J2 A)
+     (= S2 17)
+     (= K2 (- 1))
+     (= N2 16)
+     (= M2 (- 4266))
+     (= B3 (- 426))
+     (= R2 (- 4266))
+     (= P2 0)
+     (= G3 (- 2133))
+     (= T2 (- 4266))
+     (= U2 0)
+     (= W2 (- 4266))
+     (= L3 (- 21330))
+     (= V2 D)
+     (= Y2 (- 4266))
+     (= A3 E)
+     (= D3 (- 4266))
+     (= Z2 0)
+     (= K3 G)
+     (= I3 (- 4266))
+     (= Y3 8)
+     (= F3 F)
+     (= E3 1)
+     (= P3 H)
+     (= Q3 (- 267))
+     (= J3 1)
+     (= O3 4)
+     (= N3 (- 4266))
+     (= U3 I)
+     (= T3 4)
+     (= S3 (- 4266))
+     (= A4 (- 17))
+     (= Z3 J)
+     (= X3 (- 4266))
+     (= V3 (- 255))
+     (= D4 8)
+     (= C4 (- 4266))
+     (>= E4
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= O2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= J2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= V2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= A3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= K3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= F3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= P3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= U3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= Z3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (<= E4
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (not (<= X1 0))
+     (<= O2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= J2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= V2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= A3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= K3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= F3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= P3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= U3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= Z3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (= Q2 (= O2 P2)))
+      )
+      (summary_4_function_t__148_149_0 X1 H4 W I1 I4 F4 G4)
+    )
+  )
+)
+(assert
+  (forall ( (A abi_type) (B crypto_type) (C Int) (D state_type) (E state_type) (F Int) (G tx_type) ) 
+    (=>
+      (and
+        (block_34_function_t__148_149_0 C F A B G D E)
+        true
+      )
+      (summary_4_function_t__148_149_0 C F A B G D E)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) (Q Int) (R Int) (S Int) (T Int) (U Int) (V Int) (W Int) (X Int) (Y abi_type) (Z Int) (A1 Int) (B1 Int) (C1 Int) (D1 Int) (E1 Int) (F1 Int) (G1 Int) (H1 Int) (I1 Int) (J1 Int) (K1 Int) (L1 crypto_type) (M1 Int) (N1 Int) (O1 Int) (P1 Int) (Q1 Int) (R1 Int) (S1 Int) (T1 Int) (U1 Int) (V1 Int) (W1 Int) (X1 Int) (Y1 Int) (Z1 Int) (A2 Int) (B2 Int) (C2 Int) (D2 Int) (E2 Int) (F2 Int) (G2 Int) (H2 Int) (I2 Int) (J2 Int) (K2 Int) (L2 Bool) (M2 Int) (N2 Int) (O2 Int) (P2 Int) (Q2 Bool) (R2 Int) (S2 Int) (T2 Int) (U2 Int) (V2 Bool) (W2 Int) (X2 Int) (Y2 Int) (Z2 Int) (A3 Bool) (B3 Int) (C3 Int) (D3 Int) (E3 Int) (F3 Int) (G3 Int) (H3 Bool) (I3 Int) (J3 Int) (K3 Int) (L3 Int) (M3 Bool) (N3 Int) (O3 Int) (P3 Int) (Q3 Int) (R3 Bool) (S3 Int) (T3 Int) (U3 Int) (V3 Int) (W3 Bool) (X3 Int) (Y3 Int) (Z3 Int) (A4 Int) (B4 Bool) (C4 Int) (D4 Int) (E4 Int) (F4 Int) (G4 Bool) (H4 Int) (I4 Int) (J4 Int) (K4 Int) (L4 Bool) (M4 Int) (N4 Int) (O4 Int) (P4 state_type) (Q4 state_type) (R4 Int) (S4 tx_type) (v_123 state_type) (v_124 state_type) (v_125 state_type) (v_126 state_type) (v_127 state_type) (v_128 state_type) (v_129 state_type) (v_130 state_type) (v_131 state_type) (v_132 state_type) (v_133 state_type) (v_134 state_type) ) 
+    (=>
+      (and
+        (block_11_t_147_149_0 M1 R4 Y L1 S4 P4 Q4)
+        (summary_35_function_f__14_149_0 C2 R4 Y L1 S4 Q4 B3 C3 v_123 P C1 D)
+        (summary_13_function_f__14_149_0 N1 R4 Y L1 S4 Q4 D3 E3 v_124 Q D1 E)
+        (summary_33_function_f__14_149_0 A2 R4 Y L1 S4 Q4 W2 X2 v_125 O B1 C)
+        (summary_31_function_f__14_149_0 X1 R4 Y L1 S4 Q4 R2 S2 v_126 N A1 B)
+        (summary_29_function_f__14_149_0 V1 R4 Y L1 S4 Q4 M2 N2 v_127 M Z A)
+        (summary_15_function_f__14_149_0 D2 R4 Y L1 S4 Q4 I3 J3 v_128 R E1 F)
+        (summary_27_function_f__14_149_0 T1 R4 Y L1 S4 Q4 M4 N4 v_129 X K1 L)
+        (summary_25_function_f__14_149_0 R1 R4 Y L1 S4 Q4 H4 I4 v_130 W J1 K)
+        (summary_23_function_f__14_149_0 P1 R4 Y L1 S4 Q4 C4 D4 v_131 V I1 J)
+        (summary_17_function_f__14_149_0 F2 R4 Y L1 S4 Q4 N3 O3 v_132 S F1 G)
+        (summary_21_function_f__14_149_0 J2 R4 Y L1 S4 Q4 X3 Y3 v_133 U H1 I)
+        (summary_19_function_f__14_149_0 H2 R4 Y L1 S4 Q4 S3 T3 v_134 T G1 H)
+        (and (= v_123 Q4)
+     (= v_124 Q4)
+     (= v_125 Q4)
+     (= v_126 Q4)
+     (= v_127 Q4)
+     (= v_128 Q4)
+     (= v_129 Q4)
+     (= v_130 Q4)
+     (= v_131 Q4)
+     (= v_132 Q4)
+     (= v_133 Q4)
+     (= v_134 Q4)
+     (= L2 (= O4 K2))
+     (= Q2 (= O2 P2))
+     (= V2 (= T2 U2))
+     (= H3 (= F3 G3))
+     (= M3 (= K3 L3))
+     (= R3 (= P3 Q3))
+     (= W3 (= U3 V3))
+     (= B4 (= Z3 A4))
+     (= G4 (= E4 F4))
+     (= L4 (= J4 K4))
+     (= O4 L)
+     (= O1 J2)
+     (= N1 0)
+     (= P1 0)
+     (= Q1 P1)
+     (= R1 0)
+     (= S1 R1)
+     (= T1 0)
+     (= U1 T1)
+     (= Y1 N1)
+     (= X1 0)
+     (= W1 V1)
+     (= V1 0)
+     (= E2 D2)
+     (= Z1 X1)
+     (= A2 0)
+     (= B2 A2)
+     (= D2 0)
+     (= I2 H2)
+     (= H2 0)
+     (= G2 F2)
+     (= F2 0)
+     (= O2 A)
+     (= N2 16)
+     (= J2 0)
+     (= K2 (- 1))
+     (= M2 (- 4266))
+     (= Y2 C)
+     (= S2 16)
+     (= R2 (- 4266))
+     (= P2 (- 1))
+     (= T2 B)
+     (= C3 17)
+     (= U2 0)
+     (= X2 17)
+     (= W2 (- 4266))
+     (= L3 (- 426))
+     (= B3 (- 4266))
+     (= Z2 (- 1))
+     (= Q3 (- 2133))
+     (= D3 (- 4266))
+     (= E3 0)
+     (= G3 (- 4266))
+     (= V3 (- 21330))
+     (= F3 E)
+     (= I3 (- 4266))
+     (= K3 F)
+     (= N3 (- 4266))
+     (= J3 0)
+     (= U3 H)
+     (= S3 (- 4266))
+     (= I4 8)
+     (= P3 G)
+     (= O3 1)
+     (= Z3 I)
+     (= A4 (- 267))
+     (= T3 1)
+     (= Y3 4)
+     (= X3 (- 4266))
+     (= E4 J)
+     (= D4 4)
+     (= C4 (- 4266))
+     (= K4 (- 17))
+     (= J4 K)
+     (= H4 (- 4266))
+     (= F4 (- 255))
+     (= N4 8)
+     (= M4 (- 4266))
+     (>= O4
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= O2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= Y2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= T2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= F3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= K3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= U3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= P3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= Z3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= E4
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= J4
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (<= O4
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (not (<= C2 0))
+     (<= O2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= Y2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= T2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= F3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= K3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= U3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= P3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= Z3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= E4
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= J4
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (= A3 (= Y2 Z2)))
+      )
+      (summary_4_function_t__148_149_0 C2 R4 Y L1 S4 P4 Q4)
+    )
+  )
+)
+(assert
+  (forall ( (A abi_type) (B crypto_type) (C Int) (D state_type) (E state_type) (F Int) (G tx_type) ) 
+    (=>
+      (and
+        (block_36_function_t__148_149_0 C F A B G D E)
+        true
+      )
+      (summary_4_function_t__148_149_0 C F A B G D E)
+    )
+  )
+)
+(assert
+  (forall ( (A abi_type) (B crypto_type) (C Int) (D state_type) (E state_type) (F Int) (G tx_type) ) 
+    (=>
+      (and
+        (block_12_return_function_t__148_149_0 C F A B G D E)
+        true
+      )
+      (summary_4_function_t__148_149_0 C F A B G D E)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C abi_type) (D Int) (E crypto_type) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Bool) (N state_type) (O state_type) (P Int) (Q tx_type) (v_17 state_type) ) 
+    (=>
+      (and
+        (block_11_t_147_149_0 F P C E Q N O)
+        (summary_13_function_f__14_149_0 G P C E Q O I J v_17 B D A)
+        (and (= v_17 O)
+     (= G 0)
+     (= J 0)
+     (= I (- 4266))
+     (= H 1)
+     (= L (- 4266))
+     (= K A)
+     (>= K
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (<= K
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (not M)
+     (= M (= K L)))
+      )
+      (block_14_function_t__148_149_0 H P C E Q N O)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D abi_type) (E Int) (F Int) (G crypto_type) (H Int) (I state_type) (J state_type) (K Int) (L tx_type) ) 
+    (=>
+      (and
+        (summary_3_function_f__14_149_0 H K D G L I B E J C F A)
+        true
+      )
+      (summary_15_function_f__14_149_0 H K D G L I B E J C F A)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E abi_type) (F Int) (G Int) (H crypto_type) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) (Q Int) (R Bool) (S Int) (T Int) (U Int) (V Int) (W Bool) (X state_type) (Y state_type) (Z Int) (A1 tx_type) (v_27 state_type) (v_28 state_type) ) 
+    (=>
+      (and
+        (block_11_t_147_149_0 I Z E H A1 X Y)
+        (summary_15_function_f__14_149_0 L Z E H A1 Y S T v_27 D G B)
+        (summary_13_function_f__14_149_0 J Z E H A1 Y N O v_28 C F A)
+        (and (= v_27 Y)
+     (= v_28 Y)
+     (= R (= P Q))
+     (= Q (- 4266))
+     (= T 0)
+     (= M 2)
+     (= L 0)
+     (= K J)
+     (= J 0)
+     (= S (- 4266))
+     (= P A)
+     (= O 0)
+     (= N (- 4266))
+     (= V (- 426))
+     (= U B)
+     (>= P
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= U
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (<= P
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= U
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (not W)
+     (= W (= U V)))
+      )
+      (block_16_function_t__148_149_0 M Z E H A1 X Y)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D abi_type) (E Int) (F Int) (G crypto_type) (H Int) (I state_type) (J state_type) (K Int) (L tx_type) ) 
+    (=>
+      (and
+        (summary_3_function_f__14_149_0 H K D G L I B E J C F A)
+        true
+      )
+      (summary_17_function_f__14_149_0 H K D G L I B E J C F A)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G abi_type) (H Int) (I Int) (J Int) (K crypto_type) (L Int) (M Int) (N Int) (O Int) (P Int) (Q Int) (R Int) (S Int) (T Int) (U Int) (V Int) (W Bool) (X Int) (Y Int) (Z Int) (A1 Int) (B1 Bool) (C1 Int) (D1 Int) (E1 Int) (F1 Int) (G1 Bool) (H1 state_type) (I1 state_type) (J1 Int) (K1 tx_type) (v_37 state_type) (v_38 state_type) (v_39 state_type) ) 
+    (=>
+      (and
+        (block_11_t_147_149_0 L J1 G K K1 H1 I1)
+        (summary_17_function_f__14_149_0 Q J1 G K K1 I1 C1 D1 v_37 F J C)
+        (summary_13_function_f__14_149_0 M J1 G K K1 I1 S T v_38 D H A)
+        (summary_15_function_f__14_149_0 O J1 G K K1 I1 X Y v_39 E I B)
+        (and (= v_37 I1)
+     (= v_38 I1)
+     (= v_39 I1)
+     (= W (= U V))
+     (= B1 (= Z A1))
+     (= N M)
+     (= M 0)
+     (= A1 (- 426))
+     (= O 0)
+     (= R 3)
+     (= S (- 4266))
+     (= Q 0)
+     (= P O)
+     (= D1 1)
+     (= V (- 4266))
+     (= U A)
+     (= T 0)
+     (= C1 (- 4266))
+     (= Z B)
+     (= Y 0)
+     (= X (- 4266))
+     (= F1 (- 2133))
+     (= E1 C)
+     (>= U
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= Z
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= E1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (<= U
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= Z
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= E1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (not G1)
+     (= G1 (= E1 F1)))
+      )
+      (block_18_function_t__148_149_0 R J1 G K K1 H1 I1)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D abi_type) (E Int) (F Int) (G crypto_type) (H Int) (I state_type) (J state_type) (K Int) (L tx_type) ) 
+    (=>
+      (and
+        (summary_3_function_f__14_149_0 H K D G L I B E J C F A)
+        true
+      )
+      (summary_19_function_f__14_149_0 H K D G L I B E J C F A)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I abi_type) (J Int) (K Int) (L Int) (M Int) (N crypto_type) (O Int) (P Int) (Q Int) (R Int) (S Int) (T Int) (U Int) (V Int) (W Int) (X Int) (Y Int) (Z Int) (A1 Int) (B1 Bool) (C1 Int) (D1 Int) (E1 Int) (F1 Int) (G1 Bool) (H1 Int) (I1 Int) (J1 Int) (K1 Int) (L1 Bool) (M1 Int) (N1 Int) (O1 Int) (P1 Int) (Q1 Bool) (R1 state_type) (S1 state_type) (T1 Int) (U1 tx_type) (v_47 state_type) (v_48 state_type) (v_49 state_type) (v_50 state_type) ) 
+    (=>
+      (and
+        (block_11_t_147_149_0 O T1 I N U1 R1 S1)
+        (summary_19_function_f__14_149_0 V T1 I N U1 S1 M1 N1 v_47 H M D)
+        (summary_13_function_f__14_149_0 P T1 I N U1 S1 X Y v_48 E J A)
+        (summary_17_function_f__14_149_0 T T1 I N U1 S1 H1 I1 v_49 G L C)
+        (summary_15_function_f__14_149_0 R T1 I N U1 S1 C1 D1 v_50 F K B)
+        (and (= v_47 S1)
+     (= v_48 S1)
+     (= v_49 S1)
+     (= v_50 S1)
+     (= B1 (= Z A1))
+     (= G1 (= E1 F1))
+     (= L1 (= J1 K1))
+     (= S R)
+     (= X (- 4266))
+     (= P 0)
+     (= W 4)
+     (= U T)
+     (= T 0)
+     (= K1 (- 2133))
+     (= R 0)
+     (= Y 0)
+     (= Q P)
+     (= C1 (- 4266))
+     (= V 0)
+     (= A1 (- 4266))
+     (= Z A)
+     (= N1 1)
+     (= F1 (- 426))
+     (= E1 B)
+     (= D1 0)
+     (= M1 (- 4266))
+     (= J1 C)
+     (= I1 1)
+     (= H1 (- 4266))
+     (= P1 (- 21330))
+     (= O1 D)
+     (>= Z
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= E1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= J1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= O1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (<= Z
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= E1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= J1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= O1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (not Q1)
+     (= Q1 (= O1 P1)))
+      )
+      (block_20_function_t__148_149_0 W T1 I N U1 R1 S1)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D abi_type) (E Int) (F Int) (G crypto_type) (H Int) (I state_type) (J state_type) (K Int) (L tx_type) ) 
+    (=>
+      (and
+        (summary_3_function_f__14_149_0 H K D G L I B E J C F A)
+        true
+      )
+      (summary_21_function_f__14_149_0 H K D G L I B E J C F A)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K abi_type) (L Int) (M Int) (N Int) (O Int) (P Int) (Q crypto_type) (R Int) (S Int) (T Int) (U Int) (V Int) (W Int) (X Int) (Y Int) (Z Int) (A1 Int) (B1 Int) (C1 Int) (D1 Int) (E1 Int) (F1 Int) (G1 Bool) (H1 Int) (I1 Int) (J1 Int) (K1 Int) (L1 Bool) (M1 Int) (N1 Int) (O1 Int) (P1 Int) (Q1 Bool) (R1 Int) (S1 Int) (T1 Int) (U1 Int) (V1 Bool) (W1 Int) (X1 Int) (Y1 Int) (Z1 Int) (A2 Bool) (B2 state_type) (C2 state_type) (D2 Int) (E2 tx_type) (v_57 state_type) (v_58 state_type) (v_59 state_type) (v_60 state_type) (v_61 state_type) ) 
+    (=>
+      (and
+        (block_11_t_147_149_0 R D2 K Q E2 B2 C2)
+        (summary_21_function_f__14_149_0 B1 D2 K Q E2 C2 W1 X1 v_57 J P E)
+        (summary_13_function_f__14_149_0 S D2 K Q E2 C2 C1 D1 v_58 F L A)
+        (summary_19_function_f__14_149_0 Z D2 K Q E2 C2 R1 S1 v_59 I O D)
+        (summary_17_function_f__14_149_0 X D2 K Q E2 C2 M1 N1 v_60 H N C)
+        (summary_15_function_f__14_149_0 V D2 K Q E2 C2 H1 I1 v_61 G M B)
+        (and (= v_57 C2)
+     (= v_58 C2)
+     (= v_59 C2)
+     (= v_60 C2)
+     (= v_61 C2)
+     (= G1 (= E1 F1))
+     (= L1 (= J1 K1))
+     (= Q1 (= O1 P1))
+     (= V1 (= T1 U1))
+     (= X 0)
+     (= T 5)
+     (= C1 (- 4266))
+     (= Y X)
+     (= S 0)
+     (= H1 (- 4266))
+     (= U S)
+     (= W V)
+     (= Z 0)
+     (= V 0)
+     (= E1 A)
+     (= D1 0)
+     (= U1 (- 21330))
+     (= B1 0)
+     (= I1 0)
+     (= A1 Z)
+     (= M1 (- 4266))
+     (= F1 (- 4266))
+     (= K1 (- 426))
+     (= J1 B)
+     (= X1 4)
+     (= P1 (- 2133))
+     (= O1 C)
+     (= N1 1)
+     (= W1 (- 4266))
+     (= T1 D)
+     (= S1 1)
+     (= R1 (- 4266))
+     (= Z1 (- 267))
+     (= Y1 E)
+     (>= E1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= J1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= O1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= T1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= Y1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (<= E1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= J1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= O1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= T1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= Y1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (not A2)
+     (= A2 (= Y1 Z1)))
+      )
+      (block_22_function_t__148_149_0 T D2 K Q E2 B2 C2)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D abi_type) (E Int) (F Int) (G crypto_type) (H Int) (I state_type) (J state_type) (K Int) (L tx_type) ) 
+    (=>
+      (and
+        (summary_3_function_f__14_149_0 H K D G L I B E J C F A)
+        true
+      )
+      (summary_23_function_f__14_149_0 H K D G L I B E J C F A)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M abi_type) (N Int) (O Int) (P Int) (Q Int) (R Int) (S Int) (T crypto_type) (U Int) (V Int) (W Int) (X Int) (Y Int) (Z Int) (A1 Int) (B1 Int) (C1 Int) (D1 Int) (E1 Int) (F1 Int) (G1 Int) (H1 Int) (I1 Int) (J1 Int) (K1 Int) (L1 Bool) (M1 Int) (N1 Int) (O1 Int) (P1 Int) (Q1 Bool) (R1 Int) (S1 Int) (T1 Int) (U1 Int) (V1 Bool) (W1 Int) (X1 Int) (Y1 Int) (Z1 Int) (A2 Bool) (B2 Int) (C2 Int) (D2 Int) (E2 Int) (F2 Bool) (G2 Int) (H2 Int) (I2 Int) (J2 Int) (K2 Bool) (L2 state_type) (M2 state_type) (N2 Int) (O2 tx_type) (v_67 state_type) (v_68 state_type) (v_69 state_type) (v_70 state_type) (v_71 state_type) (v_72 state_type) ) 
+    (=>
+      (and
+        (block_11_t_147_149_0 U N2 M T O2 L2 M2)
+        (summary_23_function_f__14_149_0 X N2 M T O2 M2 G2 H2 v_67 L S F)
+        (summary_13_function_f__14_149_0 V N2 M T O2 M2 H1 I1 v_68 G N A)
+        (summary_21_function_f__14_149_0 G1 N2 M T O2 M2 B2 C2 v_69 K R E)
+        (summary_19_function_f__14_149_0 E1 N2 M T O2 M2 W1 X1 v_70 J Q D)
+        (summary_17_function_f__14_149_0 C1 N2 M T O2 M2 R1 S1 v_71 I P C)
+        (summary_15_function_f__14_149_0 A1 N2 M T O2 M2 M1 N1 v_72 H O B)
+        (and (= v_67 M2)
+     (= v_68 M2)
+     (= v_69 M2)
+     (= v_70 M2)
+     (= v_71 M2)
+     (= v_72 M2)
+     (= L1 (= J1 K1))
+     (= Q1 (= O1 P1))
+     (= V1 (= T1 U1))
+     (= A2 (= Y1 Z1))
+     (= F2 (= D2 E2))
+     (= Y 6)
+     (= H1 (- 4266))
+     (= D1 C1)
+     (= X 0)
+     (= W G1)
+     (= V 0)
+     (= M1 (- 4266))
+     (= I1 0)
+     (= Z V)
+     (= A1 0)
+     (= C1 0)
+     (= R1 (- 4266))
+     (= B1 A1)
+     (= E1 0)
+     (= G1 0)
+     (= J1 A)
+     (= F1 E1)
+     (= O1 B)
+     (= N1 0)
+     (= E2 (- 267))
+     (= S1 1)
+     (= K1 (- 4266))
+     (= W1 (- 4266))
+     (= P1 (- 426))
+     (= U1 (- 2133))
+     (= T1 C)
+     (= H2 4)
+     (= Z1 (- 21330))
+     (= Y1 D)
+     (= X1 1)
+     (= G2 (- 4266))
+     (= D2 E)
+     (= C2 4)
+     (= B2 (- 4266))
+     (= J2 (- 255))
+     (= I2 F)
+     (>= J1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= O1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= T1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= Y1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= D2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= I2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (<= J1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= O1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= T1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= Y1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= D2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= I2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (not K2)
+     (= K2 (= I2 J2)))
+      )
+      (block_24_function_t__148_149_0 Y N2 M T O2 L2 M2)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D abi_type) (E Int) (F Int) (G crypto_type) (H Int) (I state_type) (J state_type) (K Int) (L tx_type) ) 
+    (=>
+      (and
+        (summary_3_function_f__14_149_0 H K D G L I B E J C F A)
+        true
+      )
+      (summary_25_function_f__14_149_0 H K D G L I B E J C F A)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O abi_type) (P Int) (Q Int) (R Int) (S Int) (T Int) (U Int) (V Int) (W crypto_type) (X Int) (Y Int) (Z Int) (A1 Int) (B1 Int) (C1 Int) (D1 Int) (E1 Int) (F1 Int) (G1 Int) (H1 Int) (I1 Int) (J1 Int) (K1 Int) (L1 Int) (M1 Int) (N1 Int) (O1 Int) (P1 Int) (Q1 Bool) (R1 Int) (S1 Int) (T1 Int) (U1 Int) (V1 Bool) (W1 Int) (X1 Int) (Y1 Int) (Z1 Int) (A2 Bool) (B2 Int) (C2 Int) (D2 Int) (E2 Int) (F2 Bool) (G2 Int) (H2 Int) (I2 Int) (J2 Int) (K2 Bool) (L2 Int) (M2 Int) (N2 Int) (O2 Int) (P2 Bool) (Q2 Int) (R2 Int) (S2 Int) (T2 Int) (U2 Bool) (V2 state_type) (W2 state_type) (X2 Int) (Y2 tx_type) (v_77 state_type) (v_78 state_type) (v_79 state_type) (v_80 state_type) (v_81 state_type) (v_82 state_type) (v_83 state_type) ) 
+    (=>
+      (and
+        (block_11_t_147_149_0 X X2 O W Y2 V2 W2)
+        (summary_25_function_f__14_149_0 C1 X2 O W Y2 W2 Q2 R2 v_77 N V G)
+        (summary_13_function_f__14_149_0 Y X2 O W Y2 W2 M1 N1 v_78 H P A)
+        (summary_23_function_f__14_149_0 A1 X2 O W Y2 W2 L2 M2 v_79 M U F)
+        (summary_21_function_f__14_149_0 L1 X2 O W Y2 W2 G2 H2 v_80 L T E)
+        (summary_19_function_f__14_149_0 J1 X2 O W Y2 W2 B2 C2 v_81 K S D)
+        (summary_15_function_f__14_149_0 F1 X2 O W Y2 W2 R1 S1 v_82 I Q B)
+        (summary_17_function_f__14_149_0 H1 X2 O W Y2 W2 W1 X1 v_83 J R C)
+        (and (= v_77 W2)
+     (= v_78 W2)
+     (= v_79 W2)
+     (= v_80 W2)
+     (= v_81 W2)
+     (= v_82 W2)
+     (= v_83 W2)
+     (= Q1 (= O1 P1))
+     (= V1 (= T1 U1))
+     (= A2 (= Y1 Z1))
+     (= F2 (= D2 E2))
+     (= K2 (= I2 J2))
+     (= P2 (= N2 O2))
+     (= E1 Y)
+     (= Y 0)
+     (= Z L1)
+     (= I1 H1)
+     (= A1 0)
+     (= D1 7)
+     (= C1 0)
+     (= B1 A1)
+     (= R1 (- 4266))
+     (= N1 0)
+     (= H1 0)
+     (= G1 F1)
+     (= F1 0)
+     (= W1 (- 4266))
+     (= S1 0)
+     (= J1 0)
+     (= K1 J1)
+     (= M1 (- 4266))
+     (= B2 (- 4266))
+     (= L1 0)
+     (= O1 A)
+     (= T1 B)
+     (= P1 (- 4266))
+     (= Y1 C)
+     (= X1 1)
+     (= O2 (- 255))
+     (= C2 1)
+     (= U1 (- 426))
+     (= G2 (- 4266))
+     (= Z1 (- 2133))
+     (= E2 (- 21330))
+     (= D2 D)
+     (= R2 8)
+     (= J2 (- 267))
+     (= I2 E)
+     (= H2 4)
+     (= Q2 (- 4266))
+     (= N2 F)
+     (= M2 4)
+     (= L2 (- 4266))
+     (= T2 (- 17))
+     (= S2 G)
+     (>= O1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= T1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= Y1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= D2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= I2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= N2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= S2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (<= O1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= T1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= Y1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= D2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= I2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= N2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= S2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (not U2)
+     (= U2 (= S2 T2)))
+      )
+      (block_26_function_t__148_149_0 D1 X2 O W Y2 V2 W2)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D abi_type) (E Int) (F Int) (G crypto_type) (H Int) (I state_type) (J state_type) (K Int) (L tx_type) ) 
+    (=>
+      (and
+        (summary_3_function_f__14_149_0 H K D G L I B E J C F A)
+        true
+      )
+      (summary_27_function_f__14_149_0 H K D G L I B E J C F A)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) (Q abi_type) (R Int) (S Int) (T Int) (U Int) (V Int) (W Int) (X Int) (Y Int) (Z crypto_type) (A1 Int) (B1 Int) (C1 Int) (D1 Int) (E1 Int) (F1 Int) (G1 Int) (H1 Int) (I1 Int) (J1 Int) (K1 Int) (L1 Int) (M1 Int) (N1 Int) (O1 Int) (P1 Int) (Q1 Int) (R1 Int) (S1 Bool) (T1 Int) (U1 Int) (V1 Int) (W1 Int) (X1 Bool) (Y1 Int) (Z1 Int) (A2 Int) (B2 Int) (C2 Bool) (D2 Int) (E2 Int) (F2 Int) (G2 Int) (H2 Bool) (I2 Int) (J2 Int) (K2 Int) (L2 Int) (M2 Bool) (N2 Int) (O2 Int) (P2 Int) (Q2 Int) (R2 Bool) (S2 Int) (T2 Int) (U2 Int) (V2 Int) (W2 Bool) (X2 Int) (Y2 Int) (Z2 Int) (A3 Int) (B3 Bool) (C3 Int) (D3 Int) (E3 Int) (F3 state_type) (G3 state_type) (H3 Int) (I3 tx_type) (v_87 state_type) (v_88 state_type) (v_89 state_type) (v_90 state_type) (v_91 state_type) (v_92 state_type) (v_93 state_type) (v_94 state_type) ) 
+    (=>
+      (and
+        (block_11_t_147_149_0 A1 H3 Q Z I3 F3 G3)
+        (summary_27_function_f__14_149_0 H1 H3 Q Z I3 G3 C3 D3 v_87 P Y H)
+        (summary_13_function_f__14_149_0 B1 H3 Q Z I3 G3 T1 U1 v_88 I R A)
+        (summary_25_function_f__14_149_0 F1 H3 Q Z I3 G3 X2 Y2 v_89 O X G)
+        (summary_23_function_f__14_149_0 D1 H3 Q Z I3 G3 S2 T2 v_90 N W F)
+        (summary_21_function_f__14_149_0 Q1 H3 Q Z I3 G3 N2 O2 v_91 M V E)
+        (summary_15_function_f__14_149_0 K1 H3 Q Z I3 G3 Y1 Z1 v_92 J S B)
+        (summary_19_function_f__14_149_0 O1 H3 Q Z I3 G3 I2 J2 v_93 L U D)
+        (summary_17_function_f__14_149_0 M1 H3 Q Z I3 G3 D2 E2 v_94 K T C)
+        (and (= v_87 G3)
+     (= v_88 G3)
+     (= v_89 G3)
+     (= v_90 G3)
+     (= v_91 G3)
+     (= v_92 G3)
+     (= v_93 G3)
+     (= v_94 G3)
+     (= X1 (= V1 W1))
+     (= C2 (= A2 B2))
+     (= H2 (= F2 G2))
+     (= M2 (= K2 L2))
+     (= R2 (= P2 Q2))
+     (= W2 (= U2 V2))
+     (= B3 (= Z2 A3))
+     (= E3 H)
+     (= E1 D1)
+     (= D1 0)
+     (= B1 0)
+     (= C1 Q1)
+     (= O1 0)
+     (= I1 8)
+     (= H1 0)
+     (= G1 F1)
+     (= F1 0)
+     (= J1 B1)
+     (= K1 0)
+     (= N1 M1)
+     (= M1 0)
+     (= L1 K1)
+     (= B2 (- 426))
+     (= R1 (- 1))
+     (= Q1 0)
+     (= P1 O1)
+     (= G2 (- 2133))
+     (= T1 (- 4266))
+     (= U1 0)
+     (= W1 (- 4266))
+     (= L2 (- 21330))
+     (= V1 A)
+     (= Y1 (- 4266))
+     (= A2 B)
+     (= D2 (- 4266))
+     (= Z1 0)
+     (= K2 D)
+     (= I2 (- 4266))
+     (= Y2 8)
+     (= F2 C)
+     (= E2 1)
+     (= P2 E)
+     (= Q2 (- 267))
+     (= J2 1)
+     (= O2 4)
+     (= N2 (- 4266))
+     (= U2 F)
+     (= T2 4)
+     (= S2 (- 4266))
+     (= A3 (- 17))
+     (= Z2 G)
+     (= X2 (- 4266))
+     (= V2 (- 255))
+     (= D3 8)
+     (= C3 (- 4266))
+     (>= E3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= V1
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= A2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= K2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= F2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= P2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= U2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= Z2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (<= E3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= V1
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= A2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= K2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= F2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= P2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= U2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= Z2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (not S1)
+     (= S1 (= E3 R1)))
+      )
+      (block_28_function_t__148_149_0 I1 H3 Q Z I3 F3 G3)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D abi_type) (E Int) (F Int) (G crypto_type) (H Int) (I state_type) (J state_type) (K Int) (L tx_type) ) 
+    (=>
+      (and
+        (summary_3_function_f__14_149_0 H K D G L I B E J C F A)
+        true
+      )
+      (summary_29_function_f__14_149_0 H K D G L I B E J C F A)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) (Q Int) (R Int) (S abi_type) (T Int) (U Int) (V Int) (W Int) (X Int) (Y Int) (Z Int) (A1 Int) (B1 Int) (C1 crypto_type) (D1 Int) (E1 Int) (F1 Int) (G1 Int) (H1 Int) (I1 Int) (J1 Int) (K1 Int) (L1 Int) (M1 Int) (N1 Int) (O1 Int) (P1 Int) (Q1 Int) (R1 Int) (S1 Int) (T1 Int) (U1 Int) (V1 Int) (W1 Int) (X1 Bool) (Y1 Int) (Z1 Int) (A2 Int) (B2 Int) (C2 Bool) (D2 Int) (E2 Int) (F2 Int) (G2 Int) (H2 Bool) (I2 Int) (J2 Int) (K2 Int) (L2 Int) (M2 Bool) (N2 Int) (O2 Int) (P2 Int) (Q2 Int) (R2 Bool) (S2 Int) (T2 Int) (U2 Int) (V2 Int) (W2 Bool) (X2 Int) (Y2 Int) (Z2 Int) (A3 Int) (B3 Bool) (C3 Int) (D3 Int) (E3 Int) (F3 Int) (G3 Bool) (H3 Int) (I3 Int) (J3 Int) (K3 Int) (L3 Bool) (M3 Int) (N3 Int) (O3 Int) (P3 state_type) (Q3 state_type) (R3 Int) (S3 tx_type) (v_97 state_type) (v_98 state_type) (v_99 state_type) (v_100 state_type) (v_101 state_type) (v_102 state_type) (v_103 state_type) (v_104 state_type) (v_105 state_type) ) 
+    (=>
+      (and
+        (block_11_t_147_149_0 D1 R3 S C1 S3 P3 Q3)
+        (summary_29_function_f__14_149_0 M1 R3 S C1 S3 Q3 Y1 Z1 v_97 J T A)
+        (summary_13_function_f__14_149_0 E1 R3 S C1 S3 Q3 D2 E2 v_98 K U B)
+        (summary_27_function_f__14_149_0 K1 R3 S C1 S3 Q3 M3 N3 v_99 R B1 I)
+        (summary_25_function_f__14_149_0 I1 R3 S C1 S3 Q3 H3 I3 v_100 Q A1 H)
+        (summary_23_function_f__14_149_0 G1 R3 S C1 S3 Q3 C3 D3 v_101 P Z G)
+        (summary_15_function_f__14_149_0 P1 R3 S C1 S3 Q3 I2 J2 v_102 L V C)
+        (summary_21_function_f__14_149_0 V1 R3 S C1 S3 Q3 X2 Y2 v_103 O Y F)
+        (summary_19_function_f__14_149_0 T1 R3 S C1 S3 Q3 S2 T2 v_104 N X E)
+        (summary_17_function_f__14_149_0 R1 R3 S C1 S3 Q3 N2 O2 v_105 M W D)
+        (and (= v_97 Q3)
+     (= v_98 Q3)
+     (= v_99 Q3)
+     (= v_100 Q3)
+     (= v_101 Q3)
+     (= v_102 Q3)
+     (= v_103 Q3)
+     (= v_104 Q3)
+     (= v_105 Q3)
+     (= X1 (= O3 W1))
+     (= H2 (= F2 G2))
+     (= M2 (= K2 L2))
+     (= R2 (= P2 Q2))
+     (= W2 (= U2 V2))
+     (= B3 (= Z2 A3))
+     (= G3 (= E3 F3))
+     (= L3 (= J3 K3))
+     (= O3 I)
+     (= E1 0)
+     (= I1 0)
+     (= H1 G1)
+     (= G1 0)
+     (= F1 V1)
+     (= O1 E1)
+     (= N1 9)
+     (= J1 I1)
+     (= K1 0)
+     (= L1 K1)
+     (= M1 0)
+     (= Y1 (- 4266))
+     (= S1 R1)
+     (= R1 0)
+     (= Q1 P1)
+     (= P1 0)
+     (= T1 0)
+     (= U1 T1)
+     (= W1 (- 1))
+     (= V1 0)
+     (= L2 (- 426))
+     (= B2 (- 1))
+     (= A2 A)
+     (= Z1 16)
+     (= Q2 (- 2133))
+     (= D2 (- 4266))
+     (= E2 0)
+     (= G2 (- 4266))
+     (= V2 (- 21330))
+     (= F2 B)
+     (= I2 (- 4266))
+     (= K2 C)
+     (= N2 (- 4266))
+     (= J2 0)
+     (= U2 E)
+     (= S2 (- 4266))
+     (= I3 8)
+     (= P2 D)
+     (= O2 1)
+     (= Z2 F)
+     (= A3 (- 267))
+     (= T2 1)
+     (= Y2 4)
+     (= X2 (- 4266))
+     (= E3 G)
+     (= D3 4)
+     (= C3 (- 4266))
+     (= K3 (- 17))
+     (= J3 H)
+     (= H3 (- 4266))
+     (= F3 (- 255))
+     (= N3 8)
+     (= M3 (- 4266))
+     (>= O3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= A2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= F2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= K2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= U2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= P2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= Z2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= E3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= J3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (<= O3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= A2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= F2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= K2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= U2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= P2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= Z2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= E3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= J3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (not C2)
+     (= C2 (= A2 B2)))
+      )
+      (block_30_function_t__148_149_0 N1 R3 S C1 S3 P3 Q3)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D abi_type) (E Int) (F Int) (G crypto_type) (H Int) (I state_type) (J state_type) (K Int) (L tx_type) ) 
+    (=>
+      (and
+        (summary_3_function_f__14_149_0 H K D G L I B E J C F A)
+        true
+      )
+      (summary_31_function_f__14_149_0 H K D G L I B E J C F A)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) (Q Int) (R Int) (S Int) (T Int) (U abi_type) (V Int) (W Int) (X Int) (Y Int) (Z Int) (A1 Int) (B1 Int) (C1 Int) (D1 Int) (E1 Int) (F1 crypto_type) (G1 Int) (H1 Int) (I1 Int) (J1 Int) (K1 Int) (L1 Int) (M1 Int) (N1 Int) (O1 Int) (P1 Int) (Q1 Int) (R1 Int) (S1 Int) (T1 Int) (U1 Int) (V1 Int) (W1 Int) (X1 Int) (Y1 Int) (Z1 Int) (A2 Int) (B2 Int) (C2 Bool) (D2 Int) (E2 Int) (F2 Int) (G2 Int) (H2 Bool) (I2 Int) (J2 Int) (K2 Int) (L2 Int) (M2 Bool) (N2 Int) (O2 Int) (P2 Int) (Q2 Int) (R2 Bool) (S2 Int) (T2 Int) (U2 Int) (V2 Int) (W2 Bool) (X2 Int) (Y2 Int) (Z2 Int) (A3 Int) (B3 Bool) (C3 Int) (D3 Int) (E3 Int) (F3 Int) (G3 Bool) (H3 Int) (I3 Int) (J3 Int) (K3 Int) (L3 Bool) (M3 Int) (N3 Int) (O3 Int) (P3 Int) (Q3 Bool) (R3 Int) (S3 Int) (T3 Int) (U3 Int) (V3 Bool) (W3 Int) (X3 Int) (Y3 Int) (Z3 state_type) (A4 state_type) (B4 Int) (C4 tx_type) (v_107 state_type) (v_108 state_type) (v_109 state_type) (v_110 state_type) (v_111 state_type) (v_112 state_type) (v_113 state_type) (v_114 state_type) (v_115 state_type) (v_116 state_type) ) 
+    (=>
+      (and
+        (block_11_t_147_149_0 G1 B4 U F1 C4 Z3 A4)
+        (summary_31_function_f__14_149_0 R1 B4 U F1 C4 A4 I2 J2 v_107 L W B)
+        (summary_13_function_f__14_149_0 H1 B4 U F1 C4 A4 N2 O2 v_108 M X C)
+        (summary_29_function_f__14_149_0 P1 B4 U F1 C4 A4 D2 E2 v_109 K V A)
+        (summary_27_function_f__14_149_0 N1 B4 U F1 C4 A4 W3 X3 v_110 T E1 J)
+        (summary_25_function_f__14_149_0 L1 B4 U F1 C4 A4 R3 S3 v_111 S D1 I)
+        (summary_15_function_f__14_149_0 U1 B4 U F1 C4 A4 S2 T2 v_112 N Y D)
+        (summary_23_function_f__14_149_0 J1 B4 U F1 C4 A4 M3 N3 v_113 R C1 H)
+        (summary_21_function_f__14_149_0 A2 B4 U F1 C4 A4 H3 I3 v_114 Q B1 G)
+        (summary_19_function_f__14_149_0 Y1 B4 U F1 C4 A4 C3 D3 v_115 P A1 F)
+        (summary_17_function_f__14_149_0 W1 B4 U F1 C4 A4 X2 Y2 v_116 O Z E)
+        (and (= v_107 A4)
+     (= v_108 A4)
+     (= v_109 A4)
+     (= v_110 A4)
+     (= v_111 A4)
+     (= v_112 A4)
+     (= v_113 A4)
+     (= v_114 A4)
+     (= v_115 A4)
+     (= v_116 A4)
+     (= C2 (= Y3 B2))
+     (= H2 (= F2 G2))
+     (= R2 (= P2 Q2))
+     (= W2 (= U2 V2))
+     (= B3 (= Z2 A3))
+     (= G3 (= E3 F3))
+     (= L3 (= J3 K3))
+     (= Q3 (= O3 P3))
+     (= V3 (= T3 U3))
+     (= Y3 J)
+     (= I1 A2)
+     (= H1 0)
+     (= O1 N1)
+     (= J1 0)
+     (= K1 J1)
+     (= L1 0)
+     (= M1 L1)
+     (= N1 0)
+     (= S1 H1)
+     (= R1 0)
+     (= Q1 P1)
+     (= P1 0)
+     (= Y1 0)
+     (= X1 W1)
+     (= T1 10)
+     (= U1 0)
+     (= V1 U1)
+     (= W1 0)
+     (= I2 (- 4266))
+     (= B2 (- 1))
+     (= A2 0)
+     (= Z1 Y1)
+     (= D2 (- 4266))
+     (= E2 16)
+     (= G2 (- 1))
+     (= F2 A)
+     (= V2 (- 426))
+     (= L2 0)
+     (= K2 B)
+     (= J2 16)
+     (= A3 (- 2133))
+     (= N2 (- 4266))
+     (= O2 0)
+     (= Q2 (- 4266))
+     (= F3 (- 21330))
+     (= P2 C)
+     (= S2 (- 4266))
+     (= U2 D)
+     (= X2 (- 4266))
+     (= T2 0)
+     (= E3 F)
+     (= C3 (- 4266))
+     (= S3 8)
+     (= Z2 E)
+     (= Y2 1)
+     (= J3 G)
+     (= K3 (- 267))
+     (= D3 1)
+     (= I3 4)
+     (= H3 (- 4266))
+     (= O3 H)
+     (= N3 4)
+     (= M3 (- 4266))
+     (= U3 (- 17))
+     (= T3 I)
+     (= R3 (- 4266))
+     (= P3 (- 255))
+     (= X3 8)
+     (= W3 (- 4266))
+     (>= Y3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= F2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= K2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= P2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= U2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= E3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= Z2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= J3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= O3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= T3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (<= Y3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= F2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= K2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= P2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= U2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= E3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= Z2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= J3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= O3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= T3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (not M2)
+     (= M2 (= K2 L2)))
+      )
+      (block_32_function_t__148_149_0 T1 B4 U F1 C4 Z3 A4)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D abi_type) (E Int) (F Int) (G crypto_type) (H Int) (I state_type) (J state_type) (K Int) (L tx_type) ) 
+    (=>
+      (and
+        (summary_3_function_f__14_149_0 H K D G L I B E J C F A)
+        true
+      )
+      (summary_33_function_f__14_149_0 H K D G L I B E J C F A)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) (Q Int) (R Int) (S Int) (T Int) (U Int) (V Int) (W abi_type) (X Int) (Y Int) (Z Int) (A1 Int) (B1 Int) (C1 Int) (D1 Int) (E1 Int) (F1 Int) (G1 Int) (H1 Int) (I1 crypto_type) (J1 Int) (K1 Int) (L1 Int) (M1 Int) (N1 Int) (O1 Int) (P1 Int) (Q1 Int) (R1 Int) (S1 Int) (T1 Int) (U1 Int) (V1 Int) (W1 Int) (X1 Int) (Y1 Int) (Z1 Int) (A2 Int) (B2 Int) (C2 Int) (D2 Int) (E2 Int) (F2 Int) (G2 Int) (H2 Bool) (I2 Int) (J2 Int) (K2 Int) (L2 Int) (M2 Bool) (N2 Int) (O2 Int) (P2 Int) (Q2 Int) (R2 Bool) (S2 Int) (T2 Int) (U2 Int) (V2 Int) (W2 Bool) (X2 Int) (Y2 Int) (Z2 Int) (A3 Int) (B3 Bool) (C3 Int) (D3 Int) (E3 Int) (F3 Int) (G3 Bool) (H3 Int) (I3 Int) (J3 Int) (K3 Int) (L3 Bool) (M3 Int) (N3 Int) (O3 Int) (P3 Int) (Q3 Bool) (R3 Int) (S3 Int) (T3 Int) (U3 Int) (V3 Bool) (W3 Int) (X3 Int) (Y3 Int) (Z3 Int) (A4 Bool) (B4 Int) (C4 Int) (D4 Int) (E4 Int) (F4 Bool) (G4 Int) (H4 Int) (I4 Int) (J4 state_type) (K4 state_type) (L4 Int) (M4 tx_type) (v_117 state_type) (v_118 state_type) (v_119 state_type) (v_120 state_type) (v_121 state_type) (v_122 state_type) (v_123 state_type) (v_124 state_type) (v_125 state_type) (v_126 state_type) (v_127 state_type) ) 
+    (=>
+      (and
+        (block_11_t_147_149_0 J1 L4 W I1 M4 J4 K4)
+        (summary_33_function_f__14_149_0 X1 L4 W I1 M4 K4 S2 T2 v_117 N Z C)
+        (summary_13_function_f__14_149_0 K1 L4 W I1 M4 K4 X2 Y2 v_118 O A1 D)
+        (summary_31_function_f__14_149_0 U1 L4 W I1 M4 K4 N2 O2 v_119 M Y B)
+        (summary_29_function_f__14_149_0 S1 L4 W I1 M4 K4 I2 J2 v_120 L X A)
+        (summary_27_function_f__14_149_0 Q1 L4 W I1 M4 K4 G4 H4 v_121 V H1 K)
+        (summary_15_function_f__14_149_0 Z1 L4 W I1 M4 K4 C3 D3 v_122 P B1 E)
+        (summary_25_function_f__14_149_0 O1 L4 W I1 M4 K4 B4 C4 v_123 U G1 J)
+        (summary_23_function_f__14_149_0 M1 L4 W I1 M4 K4 W3 X3 v_124 T F1 I)
+        (summary_21_function_f__14_149_0 F2 L4 W I1 M4 K4 R3 S3 v_125 S E1 H)
+        (summary_17_function_f__14_149_0 B2 L4 W I1 M4 K4 H3 I3 v_126 Q C1 F)
+        (summary_19_function_f__14_149_0 D2 L4 W I1 M4 K4 M3 N3 v_127 R D1 G)
+        (and (= v_117 K4)
+     (= v_118 K4)
+     (= v_119 K4)
+     (= v_120 K4)
+     (= v_121 K4)
+     (= v_122 K4)
+     (= v_123 K4)
+     (= v_124 K4)
+     (= v_125 K4)
+     (= v_126 K4)
+     (= v_127 K4)
+     (= H2 (= I4 G2))
+     (= M2 (= K2 L2))
+     (= R2 (= P2 Q2))
+     (= B3 (= Z2 A3))
+     (= G3 (= E3 F3))
+     (= L3 (= J3 K3))
+     (= Q3 (= O3 P3))
+     (= V3 (= T3 U3))
+     (= A4 (= Y3 Z3))
+     (= F4 (= D4 E4))
+     (= I4 K)
+     (= K1 0)
+     (= L1 F2)
+     (= M1 0)
+     (= N1 M1)
+     (= O1 0)
+     (= S1 0)
+     (= R1 Q1)
+     (= Q1 0)
+     (= P1 O1)
+     (= Y1 11)
+     (= T1 S1)
+     (= U1 0)
+     (= V1 K1)
+     (= W1 U1)
+     (= X1 0)
+     (= C2 B2)
+     (= B2 0)
+     (= A2 Z1)
+     (= Z1 0)
+     (= I2 (- 4266))
+     (= D2 0)
+     (= E2 D2)
+     (= F2 0)
+     (= G2 (- 1))
+     (= S2 (- 4266))
+     (= L2 (- 1))
+     (= K2 A)
+     (= J2 16)
+     (= N2 (- 4266))
+     (= O2 16)
+     (= Q2 0)
+     (= P2 B)
+     (= F3 (- 426))
+     (= V2 (- 1))
+     (= U2 C)
+     (= T2 17)
+     (= K3 (- 2133))
+     (= X2 (- 4266))
+     (= Y2 0)
+     (= A3 (- 4266))
+     (= P3 (- 21330))
+     (= Z2 D)
+     (= C3 (- 4266))
+     (= E3 E)
+     (= H3 (- 4266))
+     (= D3 0)
+     (= O3 G)
+     (= M3 (- 4266))
+     (= C4 8)
+     (= J3 F)
+     (= I3 1)
+     (= T3 H)
+     (= U3 (- 267))
+     (= N3 1)
+     (= S3 4)
+     (= R3 (- 4266))
+     (= Y3 I)
+     (= X3 4)
+     (= W3 (- 4266))
+     (= E4 (- 17))
+     (= D4 J)
+     (= B4 (- 4266))
+     (= Z3 (- 255))
+     (= H4 8)
+     (= G4 (- 4266))
+     (>= I4
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= K2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= P2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= U2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= Z2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= E3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= O3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= J3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= T3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= Y3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= D4
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (<= I4
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= K2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= P2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= U2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= Z2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= E3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= O3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= J3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= T3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= Y3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= D4
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (not W2)
+     (= W2 (= U2 V2)))
+      )
+      (block_34_function_t__148_149_0 Y1 L4 W I1 M4 J4 K4)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D abi_type) (E Int) (F Int) (G crypto_type) (H Int) (I state_type) (J state_type) (K Int) (L tx_type) ) 
+    (=>
+      (and
+        (summary_3_function_f__14_149_0 H K D G L I B E J C F A)
+        true
+      )
+      (summary_35_function_f__14_149_0 H K D G L I B E J C F A)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) (Q Int) (R Int) (S Int) (T Int) (U Int) (V Int) (W Int) (X Int) (Y abi_type) (Z Int) (A1 Int) (B1 Int) (C1 Int) (D1 Int) (E1 Int) (F1 Int) (G1 Int) (H1 Int) (I1 Int) (J1 Int) (K1 Int) (L1 crypto_type) (M1 Int) (N1 Int) (O1 Int) (P1 Int) (Q1 Int) (R1 Int) (S1 Int) (T1 Int) (U1 Int) (V1 Int) (W1 Int) (X1 Int) (Y1 Int) (Z1 Int) (A2 Int) (B2 Int) (C2 Int) (D2 Int) (E2 Int) (F2 Int) (G2 Int) (H2 Int) (I2 Int) (J2 Int) (K2 Int) (L2 Int) (M2 Bool) (N2 Int) (O2 Int) (P2 Int) (Q2 Int) (R2 Bool) (S2 Int) (T2 Int) (U2 Int) (V2 Int) (W2 Bool) (X2 Int) (Y2 Int) (Z2 Int) (A3 Int) (B3 Bool) (C3 Int) (D3 Int) (E3 Int) (F3 Int) (G3 Bool) (H3 Int) (I3 Int) (J3 Int) (K3 Int) (L3 Bool) (M3 Int) (N3 Int) (O3 Int) (P3 Int) (Q3 Bool) (R3 Int) (S3 Int) (T3 Int) (U3 Int) (V3 Bool) (W3 Int) (X3 Int) (Y3 Int) (Z3 Int) (A4 Bool) (B4 Int) (C4 Int) (D4 Int) (E4 Int) (F4 Bool) (G4 Int) (H4 Int) (I4 Int) (J4 Int) (K4 Bool) (L4 Int) (M4 Int) (N4 Int) (O4 Int) (P4 Bool) (Q4 Int) (R4 Int) (S4 Int) (T4 state_type) (U4 state_type) (V4 Int) (W4 tx_type) (v_127 state_type) (v_128 state_type) (v_129 state_type) (v_130 state_type) (v_131 state_type) (v_132 state_type) (v_133 state_type) (v_134 state_type) (v_135 state_type) (v_136 state_type) (v_137 state_type) (v_138 state_type) ) 
+    (=>
+      (and
+        (block_11_t_147_149_0 M1 V4 Y L1 W4 T4 U4)
+        (summary_35_function_f__14_149_0 C2 V4 Y L1 W4 U4 C3 D3 v_127 P C1 D)
+        (summary_13_function_f__14_149_0 N1 V4 Y L1 W4 U4 H3 I3 v_128 Q D1 E)
+        (summary_33_function_f__14_149_0 A2 V4 Y L1 W4 U4 X2 Y2 v_129 O B1 C)
+        (summary_31_function_f__14_149_0 X1 V4 Y L1 W4 U4 S2 T2 v_130 N A1 B)
+        (summary_29_function_f__14_149_0 V1 V4 Y L1 W4 U4 N2 O2 v_131 M Z A)
+        (summary_15_function_f__14_149_0 E2 V4 Y L1 W4 U4 M3 N3 v_132 R E1 F)
+        (summary_27_function_f__14_149_0 T1 V4 Y L1 W4 U4 Q4 R4 v_133 X K1 L)
+        (summary_25_function_f__14_149_0 R1 V4 Y L1 W4 U4 L4 M4 v_134 W J1 K)
+        (summary_23_function_f__14_149_0 P1 V4 Y L1 W4 U4 G4 H4 v_135 V I1 J)
+        (summary_17_function_f__14_149_0 G2 V4 Y L1 W4 U4 R3 S3 v_136 S F1 G)
+        (summary_21_function_f__14_149_0 K2 V4 Y L1 W4 U4 B4 C4 v_137 U H1 I)
+        (summary_19_function_f__14_149_0 I2 V4 Y L1 W4 U4 W3 X3 v_138 T G1 H)
+        (and (= v_127 U4)
+     (= v_128 U4)
+     (= v_129 U4)
+     (= v_130 U4)
+     (= v_131 U4)
+     (= v_132 U4)
+     (= v_133 U4)
+     (= v_134 U4)
+     (= v_135 U4)
+     (= v_136 U4)
+     (= v_137 U4)
+     (= v_138 U4)
+     (= M2 (= S4 L2))
+     (= R2 (= P2 Q2))
+     (= W2 (= U2 V2))
+     (= B3 (= Z2 A3))
+     (= L3 (= J3 K3))
+     (= Q3 (= O3 P3))
+     (= V3 (= T3 U3))
+     (= A4 (= Y3 Z3))
+     (= F4 (= D4 E4))
+     (= K4 (= I4 J4))
+     (= P4 (= N4 O4))
+     (= S4 L)
+     (= N1 0)
+     (= O1 K2)
+     (= S1 R1)
+     (= R1 0)
+     (= Q1 P1)
+     (= P1 0)
+     (= T1 0)
+     (= U1 T1)
+     (= V1 0)
+     (= W1 V1)
+     (= X1 0)
+     (= Y1 N1)
+     (= C2 0)
+     (= B2 A2)
+     (= A2 0)
+     (= Z1 X1)
+     (= I2 0)
+     (= D2 12)
+     (= E2 0)
+     (= F2 E2)
+     (= G2 0)
+     (= H2 G2)
+     (= L2 (- 1))
+     (= K2 0)
+     (= J2 I2)
+     (= S2 (- 4266))
+     (= N2 (- 4266))
+     (= O2 16)
+     (= P2 A)
+     (= Q2 (- 1))
+     (= C3 (- 4266))
+     (= V2 0)
+     (= U2 B)
+     (= T2 16)
+     (= X2 (- 4266))
+     (= Y2 17)
+     (= A3 (- 1))
+     (= Z2 C)
+     (= P3 (- 426))
+     (= F3 0)
+     (= E3 D)
+     (= D3 17)
+     (= U3 (- 2133))
+     (= H3 (- 4266))
+     (= I3 0)
+     (= K3 (- 4266))
+     (= Z3 (- 21330))
+     (= J3 E)
+     (= M3 (- 4266))
+     (= O3 F)
+     (= R3 (- 4266))
+     (= N3 0)
+     (= Y3 H)
+     (= W3 (- 4266))
+     (= M4 8)
+     (= T3 G)
+     (= S3 1)
+     (= D4 I)
+     (= E4 (- 267))
+     (= X3 1)
+     (= C4 4)
+     (= B4 (- 4266))
+     (= I4 J)
+     (= H4 4)
+     (= G4 (- 4266))
+     (= O4 (- 17))
+     (= N4 K)
+     (= L4 (- 4266))
+     (= J4 (- 255))
+     (= R4 8)
+     (= Q4 (- 4266))
+     (>= S4
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= P2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= U2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= Z2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= E3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= J3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= O3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= Y3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= T3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= D4
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= I4
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= N4
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (<= S4
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= P2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= U2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= Z2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= E3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= J3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= O3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= Y3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= T3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= D4
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= I4
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= N4
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (not G3)
+     (= G3 (= E3 F3)))
+      )
+      (block_36_function_t__148_149_0 D2 V4 Y L1 W4 T4 U4)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) (E Int) (F Int) (G Int) (H Int) (I Int) (J Int) (K Int) (L Int) (M Int) (N Int) (O Int) (P Int) (Q Int) (R Int) (S Int) (T Int) (U Int) (V Int) (W Int) (X Int) (Y abi_type) (Z Int) (A1 Int) (B1 Int) (C1 Int) (D1 Int) (E1 Int) (F1 Int) (G1 Int) (H1 Int) (I1 Int) (J1 Int) (K1 Int) (L1 crypto_type) (M1 Int) (N1 Int) (O1 Int) (P1 Int) (Q1 Int) (R1 Int) (S1 Int) (T1 Int) (U1 Int) (V1 Int) (W1 Int) (X1 Int) (Y1 Int) (Z1 Int) (A2 Int) (B2 Int) (C2 Int) (D2 Int) (E2 Int) (F2 Int) (G2 Int) (H2 Int) (I2 Int) (J2 Int) (K2 Int) (L2 Int) (M2 Bool) (N2 Int) (O2 Int) (P2 Int) (Q2 Int) (R2 Bool) (S2 Int) (T2 Int) (U2 Int) (V2 Int) (W2 Bool) (X2 Int) (Y2 Int) (Z2 Int) (A3 Int) (B3 Bool) (C3 Int) (D3 Int) (E3 Int) (F3 Int) (G3 Bool) (H3 Int) (I3 Int) (J3 Int) (K3 Int) (L3 Bool) (M3 Int) (N3 Int) (O3 Int) (P3 Int) (Q3 Bool) (R3 Int) (S3 Int) (T3 Int) (U3 Int) (V3 Bool) (W3 Int) (X3 Int) (Y3 Int) (Z3 Int) (A4 Bool) (B4 Int) (C4 Int) (D4 Int) (E4 Int) (F4 Bool) (G4 Int) (H4 Int) (I4 Int) (J4 Int) (K4 Bool) (L4 Int) (M4 Int) (N4 Int) (O4 Int) (P4 Bool) (Q4 Int) (R4 Int) (S4 Int) (T4 state_type) (U4 state_type) (V4 Int) (W4 tx_type) (v_127 state_type) (v_128 state_type) (v_129 state_type) (v_130 state_type) (v_131 state_type) (v_132 state_type) (v_133 state_type) (v_134 state_type) (v_135 state_type) (v_136 state_type) (v_137 state_type) (v_138 state_type) ) 
+    (=>
+      (and
+        (block_11_t_147_149_0 M1 V4 Y L1 W4 T4 U4)
+        (summary_35_function_f__14_149_0 C2 V4 Y L1 W4 U4 C3 D3 v_127 P C1 D)
+        (summary_13_function_f__14_149_0 N1 V4 Y L1 W4 U4 H3 I3 v_128 Q D1 E)
+        (summary_33_function_f__14_149_0 A2 V4 Y L1 W4 U4 X2 Y2 v_129 O B1 C)
+        (summary_31_function_f__14_149_0 X1 V4 Y L1 W4 U4 S2 T2 v_130 N A1 B)
+        (summary_29_function_f__14_149_0 V1 V4 Y L1 W4 U4 N2 O2 v_131 M Z A)
+        (summary_15_function_f__14_149_0 E2 V4 Y L1 W4 U4 M3 N3 v_132 R E1 F)
+        (summary_27_function_f__14_149_0 T1 V4 Y L1 W4 U4 Q4 R4 v_133 X K1 L)
+        (summary_25_function_f__14_149_0 R1 V4 Y L1 W4 U4 L4 M4 v_134 W J1 K)
+        (summary_23_function_f__14_149_0 P1 V4 Y L1 W4 U4 G4 H4 v_135 V I1 J)
+        (summary_17_function_f__14_149_0 G2 V4 Y L1 W4 U4 R3 S3 v_136 S F1 G)
+        (summary_21_function_f__14_149_0 K2 V4 Y L1 W4 U4 B4 C4 v_137 U H1 I)
+        (summary_19_function_f__14_149_0 I2 V4 Y L1 W4 U4 W3 X3 v_138 T G1 H)
+        (and (= v_127 U4)
+     (= v_128 U4)
+     (= v_129 U4)
+     (= v_130 U4)
+     (= v_131 U4)
+     (= v_132 U4)
+     (= v_133 U4)
+     (= v_134 U4)
+     (= v_135 U4)
+     (= v_136 U4)
+     (= v_137 U4)
+     (= v_138 U4)
+     (= M2 (= S4 L2))
+     (= R2 (= P2 Q2))
+     (= W2 (= U2 V2))
+     (= B3 (= Z2 A3))
+     (= L3 (= J3 K3))
+     (= Q3 (= O3 P3))
+     (= V3 (= T3 U3))
+     (= A4 (= Y3 Z3))
+     (= F4 (= D4 E4))
+     (= K4 (= I4 J4))
+     (= P4 (= N4 O4))
+     (= S4 L)
+     (= N1 0)
+     (= O1 K2)
+     (= S1 R1)
+     (= R1 0)
+     (= Q1 P1)
+     (= P1 0)
+     (= T1 0)
+     (= U1 T1)
+     (= V1 0)
+     (= W1 V1)
+     (= X1 0)
+     (= Y1 N1)
+     (= C2 0)
+     (= B2 A2)
+     (= A2 0)
+     (= Z1 X1)
+     (= I2 0)
+     (= D2 C2)
+     (= E2 0)
+     (= F2 E2)
+     (= G2 0)
+     (= H2 G2)
+     (= L2 (- 1))
+     (= K2 0)
+     (= J2 I2)
+     (= S2 (- 4266))
+     (= N2 (- 4266))
+     (= O2 16)
+     (= P2 A)
+     (= Q2 (- 1))
+     (= C3 (- 4266))
+     (= V2 0)
+     (= U2 B)
+     (= T2 16)
+     (= X2 (- 4266))
+     (= Y2 17)
+     (= A3 (- 1))
+     (= Z2 C)
+     (= P3 (- 426))
+     (= F3 0)
+     (= E3 D)
+     (= D3 17)
+     (= U3 (- 2133))
+     (= H3 (- 4266))
+     (= I3 0)
+     (= K3 (- 4266))
+     (= Z3 (- 21330))
+     (= J3 E)
+     (= M3 (- 4266))
+     (= O3 F)
+     (= R3 (- 4266))
+     (= N3 0)
+     (= Y3 H)
+     (= W3 (- 4266))
+     (= M4 8)
+     (= T3 G)
+     (= S3 1)
+     (= D4 I)
+     (= E4 (- 267))
+     (= X3 1)
+     (= C4 4)
+     (= B4 (- 4266))
+     (= I4 J)
+     (= H4 4)
+     (= G4 (- 4266))
+     (= O4 (- 17))
+     (= N4 K)
+     (= L4 (- 4266))
+     (= J4 (- 255))
+     (= R4 8)
+     (= Q4 (- 4266))
+     (>= S4
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= P2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= U2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= Z2
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= E3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= J3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= O3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= Y3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= T3
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= D4
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= I4
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (>= N4
+         (- 57896044618658097711785492504343953926634992332820282019728792003956564819968))
+     (<= S4
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= P2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= U2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= Z2
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= E3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= J3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= O3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= Y3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= T3
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= D4
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= I4
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (<= N4
+         57896044618658097711785492504343953926634992332820282019728792003956564819967)
+     (= G3 (= E3 F3)))
+      )
+      (block_12_return_function_t__148_149_0 D2 V4 Y L1 W4 T4 U4)
+    )
+  )
+)
+(assert
+  (forall ( (A abi_type) (B crypto_type) (C Int) (D state_type) (E state_type) (F Int) (G tx_type) ) 
+    (=>
+      (and
+        true
+      )
+      (block_37_function_t__148_149_0 C F A B G D E)
+    )
+  )
+)
+(assert
+  (forall ( (A abi_type) (B crypto_type) (C Int) (D Int) (E Int) (F state_type) (G state_type) (H state_type) (I state_type) (J Int) (K tx_type) ) 
+    (=>
+      (and
+        (block_37_function_t__148_149_0 C J A B K F G)
+        (summary_4_function_t__148_149_0 D J A B K H I)
+        (let ((a!1 (= (select (bytes_tuple_accessor_array (msg.data K)) 3) 83))
+      (a!2 (= (select (bytes_tuple_accessor_array (msg.data K)) 2) 209))
+      (a!3 (= (select (bytes_tuple_accessor_array (msg.data K)) 1) 208))
+      (a!4 (= (select (bytes_tuple_accessor_array (msg.data K)) 0) 146))
+      (a!5 (>= (+ (select (balances G) J) E) 0))
+      (a!6 (<= (+ (select (balances G) J) E)
+               115792089237316195423570985008687907853269984665640564039457584007913129639935))
+      (a!7 (store (balances G) J (+ (select (balances G) J) E))))
+  (and (= G F)
+       a!1
+       a!2
+       a!3
+       a!4
+       (= (msg.value K) 0)
+       (= (msg.sig K) 2463158611)
+       (= C 0)
+       (>= (tx.origin K) 0)
+       (>= (tx.gasprice K) 0)
+       (>= (msg.value K) 0)
+       (>= (msg.sender K) 0)
+       (>= (block.timestamp K) 0)
+       (>= (block.number K) 0)
+       (>= (block.gaslimit K) 0)
+       (>= (block.difficulty K) 0)
+       (>= (block.coinbase K) 0)
+       (>= (block.chainid K) 0)
+       (>= (block.basefee K) 0)
+       (>= (bytes_tuple_accessor_length (msg.data K)) 4)
+       a!5
+       (>= E (msg.value K))
+       (<= (tx.origin K) 1461501637330902918203684832716283019655932542975)
+       (<= (tx.gasprice K)
+           115792089237316195423570985008687907853269984665640564039457584007913129639935)
+       (<= (msg.value K)
+           115792089237316195423570985008687907853269984665640564039457584007913129639935)
+       (<= (msg.sender K) 1461501637330902918203684832716283019655932542975)
+       (<= (block.timestamp K)
+           115792089237316195423570985008687907853269984665640564039457584007913129639935)
+       (<= (block.number K)
+           115792089237316195423570985008687907853269984665640564039457584007913129639935)
+       (<= (block.gaslimit K)
+           115792089237316195423570985008687907853269984665640564039457584007913129639935)
+       (<= (block.difficulty K)
+           115792089237316195423570985008687907853269984665640564039457584007913129639935)
+       (<= (block.coinbase K) 1461501637330902918203684832716283019655932542975)
+       (<= (block.chainid K)
+           115792089237316195423570985008687907853269984665640564039457584007913129639935)
+       (<= (block.basefee K)
+           115792089237316195423570985008687907853269984665640564039457584007913129639935)
+       a!6
+       (= H (state_type a!7))))
+      )
+      (summary_5_function_t__148_149_0 D J A B K F I)
+    )
+  )
+)
+(assert
+  (forall ( (A abi_type) (B crypto_type) (C Int) (D state_type) (E state_type) (F Int) (G tx_type) ) 
+    (=>
+      (and
+        (summary_5_function_t__148_149_0 C F A B G D E)
+        (interface_0_C_149_0 F A B D)
+        (= C 0)
+      )
+      (interface_0_C_149_0 F A B E)
+    )
+  )
+)
+(assert
+  (forall ( (A abi_type) (B crypto_type) (C Int) (D state_type) (E state_type) (F Int) (G tx_type) ) 
+    (=>
+      (and
+        (summary_constructor_2_C_149_0 C F A B G D E)
+        (and (= C 0)
+     (>= (tx.origin G) 0)
+     (>= (tx.gasprice G) 0)
+     (>= (msg.value G) 0)
+     (>= (msg.sender G) 0)
+     (>= (block.timestamp G) 0)
+     (>= (block.number G) 0)
+     (>= (block.gaslimit G) 0)
+     (>= (block.difficulty G) 0)
+     (>= (block.coinbase G) 0)
+     (>= (block.chainid G) 0)
+     (>= (block.basefee G) 0)
+     (<= (tx.origin G) 1461501637330902918203684832716283019655932542975)
+     (<= (tx.gasprice G)
+         115792089237316195423570985008687907853269984665640564039457584007913129639935)
+     (<= (msg.value G)
+         115792089237316195423570985008687907853269984665640564039457584007913129639935)
+     (<= (msg.sender G) 1461501637330902918203684832716283019655932542975)
+     (<= (block.timestamp G)
+         115792089237316195423570985008687907853269984665640564039457584007913129639935)
+     (<= (block.number G)
+         115792089237316195423570985008687907853269984665640564039457584007913129639935)
+     (<= (block.gaslimit G)
+         115792089237316195423570985008687907853269984665640564039457584007913129639935)
+     (<= (block.difficulty G)
+         115792089237316195423570985008687907853269984665640564039457584007913129639935)
+     (<= (block.coinbase G) 1461501637330902918203684832716283019655932542975)
+     (<= (block.chainid G)
+         115792089237316195423570985008687907853269984665640564039457584007913129639935)
+     (<= (block.basefee G)
+         115792089237316195423570985008687907853269984665640564039457584007913129639935)
+     (= (msg.value G) 0))
+      )
+      (interface_0_C_149_0 F A B E)
+    )
+  )
+)
+(assert
+  (forall ( (A abi_type) (B crypto_type) (C Int) (D state_type) (E state_type) (F Int) (G tx_type) ) 
+    (=>
+      (and
+        (and (= C 0) (= E D))
+      )
+      (contract_initializer_entry_39_C_149_0 C F A B G D E)
+    )
+  )
+)
+(assert
+  (forall ( (A abi_type) (B crypto_type) (C Int) (D state_type) (E state_type) (F Int) (G tx_type) ) 
+    (=>
+      (and
+        (contract_initializer_entry_39_C_149_0 C F A B G D E)
+        true
+      )
+      (contract_initializer_after_init_40_C_149_0 C F A B G D E)
+    )
+  )
+)
+(assert
+  (forall ( (A abi_type) (B crypto_type) (C Int) (D state_type) (E state_type) (F Int) (G tx_type) ) 
+    (=>
+      (and
+        (contract_initializer_after_init_40_C_149_0 C F A B G D E)
+        true
+      )
+      (contract_initializer_38_C_149_0 C F A B G D E)
+    )
+  )
+)
+(assert
+  (forall ( (A abi_type) (B crypto_type) (C Int) (D state_type) (E state_type) (F Int) (G tx_type) ) 
+    (=>
+      (and
+        (and (= C 0) (>= (select (balances E) F) (msg.value G)) (= E D))
+      )
+      (implicit_constructor_entry_41_C_149_0 C F A B G D E)
+    )
+  )
+)
+(assert
+  (forall ( (A abi_type) (B crypto_type) (C Int) (D Int) (E state_type) (F state_type) (G state_type) (H Int) (I tx_type) ) 
+    (=>
+      (and
+        (implicit_constructor_entry_41_C_149_0 C H A B I E F)
+        (contract_initializer_38_C_149_0 D H A B I F G)
+        (not (<= D 0))
+      )
+      (summary_constructor_2_C_149_0 D H A B I E G)
+    )
+  )
+)
+(assert
+  (forall ( (A abi_type) (B crypto_type) (C Int) (D Int) (E state_type) (F state_type) (G state_type) (H Int) (I tx_type) ) 
+    (=>
+      (and
+        (contract_initializer_38_C_149_0 D H A B I F G)
+        (implicit_constructor_entry_41_C_149_0 C H A B I E F)
+        (= D 0)
+      )
+      (summary_constructor_2_C_149_0 D H A B I E G)
+    )
+  )
+)
+(assert
+  (forall ( (A abi_type) (B crypto_type) (C Int) (D state_type) (E state_type) (F Int) (G tx_type) ) 
+    (=>
+      (and
+        (summary_5_function_t__148_149_0 C F A B G D E)
+        (interface_0_C_149_0 F A B D)
+        (= C 6)
+      )
+      error_target_19_0
+    )
+  )
+)
+(assert
+  (forall ( (CHC_COMP_UNUSED Bool) ) 
+    (=>
+      (and
+        error_target_19_0
+        true
+      )
+      false
+    )
+  )
+)
+
+(check-sat)
+(exit)

From b5717c8c5589a0ce6f396b3b5945da22ba216e25 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Wed, 22 Jul 2026 14:39:00 +0200
Subject: [PATCH 76/77] properly exclude CPALog.txt files

---
 .gitignore | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.gitignore b/.gitignore
index 3a5dad4373..67afebceb0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -84,3 +84,5 @@ hs_err_*.log
 
 CPALog.txt
 CPALog.txt.lck
+CPALog.txt.*
+CPALog.txt.*.lck

From c07065dd6299ad305576c1eacc1ffb6549b1e8e2 Mon Sep 17 00:00:00 2001
From: Moritz Zwerger <bixilon@bixilon.de>
Date: Wed, 22 Jul 2026 14:39:26 +0200
Subject: [PATCH 77/77] eldarica: properly rewrite (nested) epsilon terms

---
 .../eldarica/PrincessHornConverter.java       | 49 ++++++++++-------
 .../java_smt/test/horn/HornExampleTest.java   |  7 +++
 .../java_smt/test/horn/s_split_23_000.license |  1 +
 .../java_smt/test/horn/s_split_23_000.smt2    | 54 +++++++++++++++++++
 4 files changed, 92 insertions(+), 19 deletions(-)
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/s_split_23_000.license
 create mode 100644 src/org/sosy_lab/java_smt/test/horn/s_split_23_000.smt2

diff --git a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
index a616888e4d..6550c18dc4 100644
--- a/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
+++ b/src/org/sosy_lab/java_smt/solvers/princess/eldarica/PrincessHornConverter.java
@@ -30,6 +30,7 @@
 import ap.parser.ITerm;
 import ap.parser.ITermITE;
 import ap.parser.ITimes;
+import ap.parser.VariableSubstVisitor;
 import ap.terfor.ConstantTerm;
 import ap.terfor.conjunctions.Quantifier.ALL$;
 import ap.terfor.preds.Predicate;
@@ -43,6 +44,8 @@
 import lazabs.horn.bottomup.HornClauses;
 import lazabs.horn.bottomup.HornClauses.Clause;
 import org.checkerframework.checker.nullness.qual.Nullable;
+import scala.Tuple2;
+import scala.collection.JavaConverters;
 import scala.collection.Seq$;
 import scala.collection.immutable.List$;
 import scala.collection.immutable.Seq;
@@ -77,7 +80,7 @@ class ClauseContext {
     private final ArrayList<IConstant> variables = new ArrayList<>();
     private IFormula constraint = new IBoolLit(true);
     private int temporary = 0;
-    private boolean epsilon = false;
+    private int epsilon = 0;
 
 
     private List<IFormula> flatten(final IBinFormula input) {
@@ -307,15 +310,8 @@ private IConstant toVariable(int index, Sort sort) {
         }
       }
 
-      ConstantTerm term;
-
-      if (sort == Integer$.MODULE$) {
-        term = new ConstantTerm(name);
-      } else {
-        term = new SortedConstantTerm(name, sort);
-      }
 
-      var constant = new IConstant(term);
+      var constant = createVariable(name, sort);
       variables.add(constant);
       return constant;
 
@@ -325,27 +321,42 @@ private IConstant toVariable(final ISortedVariable variable) {
       return toVariable(variable.index(), variable.sort());
     }
 
-    private IConstant createVariable(String prefix, int index) {
-      return new IConstant(new ConstantTerm(prefix + index));
+    private IConstant createVariable(String name, Sort sort) {
+      ConstantTerm term;
+
+      if (sort == Integer$.MODULE$) {
+        term = new ConstantTerm(name);
+      } else {
+        term = new SortedConstantTerm(name, sort);
+      }
+
+      return new IConstant(term);
+    }
+
+    private IConstant createVariable(String prefix, int index, Sort sort) {
+      var name = prefix + index;
+      return createVariable(name, sort);
     }
 
     private ITerm toTerm(final ISortedEpsilon epsilon) {
-      if (this.epsilon) {
-        throw new IllegalStateException("Can not nest epsilon terms (yet)!");
-      }
-      this.epsilon = true;
+      var variable = createVariable("E", this.epsilon++, epsilon.sort());
+
+      var substitution = JavaConverters.asScala(List.of((ITerm) variable)).toList();
+
+      IFormula rewritten = VariableSubstVisitor.apply(
+          epsilon.cond(),
+          new Tuple2<>(substitution, -1)
+      );
 
-      var variable = toVariable(0, epsilon.sort());
-      var condition = toFormula(epsilon.cond());
+      var condition = toFormula(rewritten);
 
       this.constraint = this.constraint.andSimplify(condition);
 
-      this.epsilon = false;
       return variable;
     }
 
     private ITerm toTerm(final ITermITE ite) {
-      var variable = createVariable("T", temporary++);
+      var variable = createVariable("T", temporary++, Integer$.MODULE$);
       var condition = toFormula(ite.cond());
 
       var left = toTerm(ite.left());
diff --git a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
index 56854673f7..12d5f74800 100644
--- a/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
+++ b/src/org/sosy_lab/java_smt/test/horn/HornExampleTest.java
@@ -242,6 +242,13 @@ public void smt_s_split_37_000() throws Exception {
     assertTrue(prover.isUnsat());
   }
 
+  @Test
+  public void smt_s_split_23_000() throws Exception { // endless looking for interpolants
+    var prover = solveSmtLib2("s_split_23_000");
+
+    assertFalse(prover.isUnsat());
+  }
+
   @Test
   public void smt_small_unsat() throws Exception {
     /*
diff --git a/src/org/sosy_lab/java_smt/test/horn/s_split_23_000.license b/src/org/sosy_lab/java_smt/test/horn/s_split_23_000.license
new file mode 100644
index 0000000000..1abba28dd5
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/s_split_23_000.license
@@ -0,0 +1 @@
+SPDX-License-Identifier: Apache-2.0
diff --git a/src/org/sosy_lab/java_smt/test/horn/s_split_23_000.smt2 b/src/org/sosy_lab/java_smt/test/horn/s_split_23_000.smt2
new file mode 100644
index 0000000000..a7e6777682
--- /dev/null
+++ b/src/org/sosy_lab/java_smt/test/horn/s_split_23_000.smt2
@@ -0,0 +1,54 @@
+(set-logic HORN)
+
+
+(declare-fun |fail| ( ) Bool)
+(declare-fun |inv| ( Int Int ) Bool)
+
+(assert
+  (forall ( (A Int) (B Int) ) 
+    (=>
+      (and
+        (and (= B 100) (= A 1000))
+      )
+      (inv A B)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) (C Int) (D Int) ) 
+    (=>
+      (and
+        (inv A B)
+        (let ((a!1 (= D (ite (<= B (div A 10)) (+ 1 B) (+ (- 1) B))))
+      (a!2 (= C (ite (<= B (div A 10)) (+ (- 1) A) (+ 1 A)))))
+  (and a!1 a!2))
+      )
+      (inv C D)
+    )
+  )
+)
+(assert
+  (forall ( (A Int) (B Int) ) 
+    (=>
+      (and
+        (inv B A)
+        (<= B A)
+      )
+      fail
+    )
+  )
+)
+(assert
+  (forall ( (CHC_COMP_UNUSED Bool) ) 
+    (=>
+      (and
+        fail
+        true
+      )
+      false
+    )
+  )
+)
+
+(check-sat)
+(exit)