diff --git a/Main.hs b/Main.hs
deleted file mode 100644
--- a/Main.hs
+++ /dev/null
@@ -1,625 +0,0 @@
-{-# LANGUAGE CPP, RecordWildCards, FlexibleInstances, PatternGuards #-}
-import Control.Monad
-import Data.Char
-import Data.Either
-import Twee hiding (message)
-import Twee.Base hiding (char, lookup, vars)
-import Twee.Rule(lhs, rhs, unorient)
-import Twee.Equation
-import qualified Twee.Proof as Proof
-import Twee.Proof hiding (Config, defaultConfig)
-import qualified Twee.Join as Join
-import Twee.Utils
-import qualified Twee.CP as CP
-import Data.Ord
-import qualified Data.Map.Strict as Map
-import qualified Twee.KBO as KBO
-import Data.List.Split
-import Data.List
-import Data.Maybe
-import Jukebox.Options
-import Jukebox.Toolbox
-import Jukebox.Name hiding (lhs, rhs)
-import qualified Jukebox.Form as Jukebox
-import Jukebox.Form hiding ((:=:), Var, Symbolic(..), Term, Axiom, size, Lemma)
-import Jukebox.Tools.EncodeTypes
-import Jukebox.TPTP.Print
-import Jukebox.Tools.HornToUnit
-import qualified Data.IntMap.Strict as IntMap
-import System.IO
-import System.Exit
-import qualified Data.Set as Set
-
-data MainFlags =
-  MainFlags {
-    flags_proof :: Bool,
-    flags_trace :: Maybe (String, String) }
-
-parseMainFlags :: OptionParser MainFlags
-parseMainFlags =
-  MainFlags <$> proof <*> trace
-  where
-    proof =
-      inGroup "Output options" $
-      bool "proof" ["Produce proofs (on by default)."]
-      True
-    trace =
-      expert $
-      inGroup "Output options" $
-      flag "trace"
-        ["Write a Prolog-format execution trace to this file (off by default)."]
-        Nothing ((\x y -> Just (x, y)) <$> argFile <*> argModule)
-    argModule = arg "<module>" "expected a Prolog module name" Just
-
-parseConfig :: OptionParser Config
-parseConfig =
-  Config <$> maxSize <*> maxCPs <*> maxCPDepth <*> simplify <*> normPercent <*>
-    (CP.Config <$> lweight <*> rweight <*> funweight <*> varweight <*> depthweight <*> dupcost <*> dupfactor) <*>
-    (Join.Config <$> ground_join <*> connectedness <*> set_join) <*>
-    (Proof.Config <$> all_lemmas <*> flat_proof <*> show_instances)
-  where
-    maxSize =
-      inGroup "Resource limits" $
-      flag "max-term-size" ["Discard rewrite rules whose left-hand side is bigger than this limit (unlimited by default)."] maxBound argNum
-    maxCPs =
-      inGroup "Resource limits" $
-      flag "max-cps" ["Give up after considering this many critical pairs (unlimited by default)."] maxBound argNum
-    maxCPDepth =
-      inGroup "Resource limits" $
-      flag "max-cp-depth" ["Only consider critical pairs up to this depth (unlimited by default)."] maxBound argNum
-    simplify =
-      expert $
-      inGroup "Completion heuristics" $
-      bool "simplify"
-        ["Simplify rewrite rules with respect to one another (on by default)."]
-        True
-    normPercent =
-      expert $
-      inGroup "Completion heuristics" $
-      defaultFlag "normalise-queue-percent" "Percent of time spent renormalising queued critical pairs" (cfg_renormalise_percent) argNum
-    lweight =
-      expert $
-      inGroup "Critical pair weighting heuristics" $
-      defaultFlag "lhs-weight" "Weight given to LHS of critical pair" (CP.cfg_lhsweight . cfg_critical_pairs) argNum
-    rweight =
-      expert $
-      inGroup "Critical pair weighting heuristics" $
-      defaultFlag "rhs-weight" "Weight given to RHS of critical pair" (CP.cfg_rhsweight . cfg_critical_pairs) argNum
-    funweight =
-      expert $
-      inGroup "Critical pair weighting heuristics" $
-      defaultFlag "fun-weight" "Weight given to function symbols" (CP.cfg_funweight . cfg_critical_pairs) argNum
-    varweight =
-      expert $
-      inGroup "Critical pair weighting heuristics" $
-      defaultFlag "var-weight" "Weight given to variable symbols" (CP.cfg_varweight . cfg_critical_pairs) argNum
-    depthweight =
-      expert $
-      inGroup "Critical pair weighting heuristics" $
-      defaultFlag "depth-weight" "Weight given to critical pair depth" (CP.cfg_depthweight . cfg_critical_pairs) argNum
-    dupcost =
-      expert $
-      inGroup "Critical pair weighting heuristics" $
-      defaultFlag "dup-cost" "Cost of duplicate subterms" (CP.cfg_dupcost . cfg_critical_pairs) argNum
-    dupfactor =
-      expert $
-      inGroup "Critical pair weighting heuristics" $
-      defaultFlag "dup-factor" "Size factor of duplicate subterms" (CP.cfg_dupfactor . cfg_critical_pairs) argNum
-    ground_join =
-      expert $
-      inGroup "Critical pair joining heuristics" $
-      bool "ground-joining"
-        ["Test terms for ground joinability (on by default)."]
-        True
-    connectedness =
-      expert $
-      inGroup "Critical pair joining heuristics" $
-      bool "connectedness"
-        ["Test terms for subconnectedness (on by default)."]
-        True
-    set_join =
-      expert $
-      inGroup "Critical pair joining heuristics" $
-      bool "set-join"
-        ["Compute all normal forms when joining critical pairs (off by default)."]
-        False
-    all_lemmas =
-      expert $
-      inGroup "Proof presentation" $
-      bool "all-lemmas"
-        ["Produce a proof with one lemma for each critical pair (off by default)."]
-        False
-    flat_proof =
-      expert $
-      inGroup "Proof presentation" $
-      bool "no-lemmas"
-        ["Produce a proof with no lemmas (off by default).",
-         "May lead to exponentially large proofs."]
-        False
-    show_instances =
-      expert $
-      inGroup "Proof presentation" $
-      bool "show-instances"
-        ["Show which instances of each axiom and lemma were used (off by default)."]
-        False
-    defaultFlag name desc field parser =
-      flag name [desc ++ " (" ++ show def ++ " by default)."] def parser
-      where
-        def = field defaultConfig
-
-parsePrecedence :: OptionParser [String]
-parsePrecedence =
-  expert $
-  inGroup "Term order options" $
-  fmap (splitOn ",")
-  (flag "precedence" ["List of functions in descending order of precedence."] [] (arg "<function>" "expected a function name" Just))
-
-data Constant =
-  Constant {
-    con_prec  :: {-# UNPACK #-} !Precedence,
-    con_id    :: {-# UNPACK #-} !Jukebox.Function,
-    con_arity :: {-# UNPACK #-} !Int,
-    con_size  :: {-# UNPACK #-} !Int,
-    con_bonus :: !Bool }
-  deriving (Eq, Ord)
-
-data Precedence = Precedence !Bool !Bool !(Maybe Int) !Int
-  deriving (Eq, Ord)
-
-instance Sized Constant where
-  size Constant{..} = con_size
-instance Arity Constant where
-  arity Constant{..} = con_arity
-
-instance Pretty Constant where
-  pPrint Constant{..} = text (base con_id)
-
-instance PrettyTerm Constant where
-  termStyle Constant{..}
-    | "$to_" `isPrefixOf` (base con_id) = invisible
-    | any isAlphaNum (base con_id) = uncurried
-    | otherwise =
-      case con_arity of
-        1 -> prefix
-        2 -> infixStyle 5
-        _ -> uncurried
-
-instance Ordered (Extended Constant) where
-  lessEq t u = {-# SCC lessEq #-} KBO.lessEq t u
-  lessIn model t u = {-# SCC lessIn #-} KBO.lessIn model t u
-
-instance EqualsBonus Constant where
-  hasEqualsBonus = con_bonus
-  isEquals = Main.isEquals . con_id
-  isTrue = Main.isTrue . con_id
-  isFalse = Main.isFalse . con_id
-
-data TweeContext =
-  TweeContext {
-    ctx_var     :: Jukebox.Variable,
-    ctx_minimal :: Jukebox.Function,
-    ctx_true    :: Jukebox.Function,
-    ctx_false   :: Jukebox.Function,
-    ctx_equals  :: Jukebox.Function,
-    ctx_type    :: Type }
-
--- Convert back and forth between Twee and Jukebox.
-tweeConstant :: HornFlags -> TweeContext -> Precedence -> Jukebox.Function -> Extended Constant
-tweeConstant flags TweeContext{..} prec fun
-  | fun == ctx_minimal = Minimal
-  | otherwise = Function (Constant prec fun (Jukebox.arity fun) (sz fun) (bonus fun))
-  where
-    sz fun = if isType fun then 0 else 1
-    bonus fun =
-      (isIfeq fun && encoding flags /= Asymmetric2) ||
-      Main.isEquals fun
-
-isType :: Jukebox.Function -> Bool
-isType fun = "$to_" `isPrefixOf` base (name fun)
-
-isIfeq :: Jukebox.Function -> Bool
-isIfeq fun = "$ifeq" `isPrefixOf` base (name fun)
-
-isEquals :: Jukebox.Function -> Bool
-isEquals fun = "$equals" `isPrefixOf` base (name fun)
-
-isTrue :: Jukebox.Function -> Bool
-isTrue fun = "$true" `isPrefixOf` base (name fun)
-
-isFalse :: Jukebox.Function -> Bool
-isFalse fun = "$false" `isPrefixOf` base (name fun)
-
-jukeboxFunction :: TweeContext -> Extended Constant -> Jukebox.Function
-jukeboxFunction _ (Function Constant{..}) = con_id
-jukeboxFunction TweeContext{..} Minimal = ctx_minimal
-jukeboxFunction TweeContext{..} (Skolem _) =
-  error "Skolem variable leaked into rule"
-
-tweeTerm :: HornFlags -> TweeContext -> (Jukebox.Function -> Precedence) -> Jukebox.Term -> Term (Extended Constant)
-tweeTerm flags ctx prec t = build (tm t)
-  where
-    tm (Jukebox.Var (Unique x _ _ ::: _)) =
-      var (V (fromIntegral x))
-    tm (f :@: ts) =
-      app (fun (tweeConstant flags ctx (prec f) f)) (map tm ts)
-
-jukeboxTerm :: TweeContext -> Term (Extended Constant) -> Jukebox.Term
-jukeboxTerm TweeContext{..} (Var (V x)) =
-  Jukebox.Var (Unique (fromIntegral x) "X" defaultRenamer ::: ctx_type)
-jukeboxTerm ctx@TweeContext{..} (App f t) =
-  jukeboxFunction ctx (fun_value f) :@: map (jukeboxTerm ctx) ts
-  where
-    ts = unpack t
-
-makeContext :: Problem Clause -> TweeContext
-makeContext prob = run prob $ \prob -> do
-  let
-    ty =
-      case types' prob of
-        []   -> indType
-        [ty] -> ty
-
-  var     <- newSymbol "X" ty
-  minimal <- newFunction "$constant" [] ty
-  true    <- newFunction "$true" [] ty
-  false   <- newFunction "$false" [] ty
-  equals  <- newFunction "$equals" [ty, ty] ty
-
-  return TweeContext {
-    ctx_var = var,
-    ctx_minimal = minimal,
-    ctx_true = true,
-    ctx_false = false,
-    ctx_equals = equals,
-    ctx_type = ty }
-
--- Encode existentials so that all goals are ground.
-addNarrowing :: TweeContext -> Problem Clause -> Problem Clause
-addNarrowing TweeContext{..} prob =
-  unchanged ++ equalityClauses
-  where
-    (unchanged, nonGroundGoals) = partitionEithers (map f prob)
-      where
-        f inp@Input{what = Clause (Bind _ [Neg (x Jukebox.:=: y)])}
-          | not (ground x) || not (ground y) =
-            Right (inp, (x, y))
-        f inp = Left inp
-
-    equalityClauses
-      | null nonGroundGoals = []
-      | otherwise =
-        -- Turn a != b & c != d & ...
-        -- into eq(a,b)=false & eq(c,d)=false & eq(X,X)=true & true!=false (esa)
-        -- and then extract the individual components (thm)
-        let
-          equalityLiterals =
-            -- true != false
-            ("true_equals_false", Neg ((ctx_true :@:) [] Jukebox.:=: (ctx_false :@: []))):
-            -- eq(X,X)=true
-            ("reflexivity", Pos (ctx_equals :@: [Jukebox.Var ctx_var, Jukebox.Var ctx_var] Jukebox.:=: (ctx_true :@: []))):
-            -- [eq(a,b)=false, eq(c,d)=false, ...]
-            [ (tag, Pos (ctx_equals :@: [x, y] Jukebox.:=: (ctx_false :@: [])))
-            | (Input{tag = tag}, (x, y)) <- nonGroundGoals ]
-
-          -- Equisatisfiable to the input clauses
-          justification =
-            Input {
-              tag  = "new_negated_conjecture",
-              kind = Jukebox.Ax NegatedConjecture,
-              what =
-                let form = And (map (Literal . snd) equalityLiterals) in
-                ForAll (Bind (Set.fromList (vars form)) form),
-              source =
-                Inference "encode_existential" "esa"
-                  (map (fmap toForm . fst) nonGroundGoals) }
-
-          input tag form =
-            Input {
-              tag = tag,
-              kind = Conj Conjecture,
-              what = clause [form],
-              source =
-                Inference "split_conjunct" "thm" [justification] }
-
-        in [input tag form | (tag, form) <- equalityLiterals]
-
-data PreEquation =
-  PreEquation {
-    pre_name :: String,
-    pre_form :: Input Form,
-    pre_eqn  :: (Jukebox.Term, Jukebox.Term) }
-
--- Split the problem into axioms and ground goals.
-identifyProblem ::
-  TweeContext -> Problem Clause -> Either (Input Clause) ([PreEquation], [PreEquation])
-identifyProblem TweeContext{..} prob =
-  fmap partitionEithers (mapM identify prob)
-
-  where
-    pre inp x =
-      PreEquation {
-        pre_name = tag inp,
-        pre_form = fmap toForm inp,
-        pre_eqn = x }
-
-    identify inp@Input{what = Clause (Bind _ [Pos (t Jukebox.:=: u)])} =
-      return $ Left (pre inp (t, u))
-    identify inp@Input{what = Clause (Bind _ [Neg (t Jukebox.:=: u)])}
-      | ground t && ground u =
-        return $ Right (pre inp (t, u))
-    identify inp@Input{what = Clause (Bind _ [])} =
-      -- The empty clause can appear after clausification if
-      -- the conjecture was trivial
-      return $ Left (pre inp (Jukebox.Var ctx_var, ctx_minimal :@: []))
-    identify inp = Left inp
-
-runTwee :: GlobalFlags -> TSTPFlags -> MainFlags -> HornFlags -> Config -> [String] -> (IO () -> IO ()) -> Problem Clause -> IO Answer
-runTwee globals (TSTPFlags tstp) main horn config precedence later obligs = {-# SCC runTwee #-} do
-  let
-    -- Encode whatever needs encoding in the problem
-    ctx = makeContext obligs
-    prob = addNarrowing ctx obligs
-
-  (axioms0, goals0) <-
-    case identifyProblem ctx prob of
-      Left inp -> do
-        mapM_ (hPutStrLn stderr) [
-          "The problem contains the following clause, which is not a unit equality:",
-          indent (show (pPrintClauses [inp])),
-          "Twee only handles unit equality problems."]
-        exitWith (ExitFailure 1)
-      Right x -> return x
-
-  let
-    -- Work out a precedence for function symbols
-    prec c =
-      Precedence
-        (isType c)
-        (isNothing (elemIndex (base c) precedence))
-        (fmap negate (elemIndex (base c) precedence))
-        (negate (Map.findWithDefault 0 c occs))
-    occs = funsOcc prob
-
-    -- Translate everything to Twee.
-    toEquation (t, u) =
-      canonicalise (tweeTerm horn ctx prec t :=: tweeTerm horn ctx prec u)
-
-    goals =
-      [ goal n pre_name (toEquation pre_eqn)
-      | (n, PreEquation{..}) <- zip [1..] goals0 ]
-    axioms =
-      [ Axiom n pre_name (toEquation pre_eqn)
-      | (n, PreEquation{..}) <- zip [1..] axioms0 ]
-
-    withGoals = foldl' (addGoal config) initialState goals
-    withAxioms = foldl' (addAxiom config) withGoals axioms
-
-  -- Set up tracing.
-  sayTrace <-
-    case flags_trace main of
-      Nothing -> return $ \_ -> return ()
-      Just (file, mod) -> do
-        h <- openFile file WriteMode
-        hSetBuffering h LineBuffering
-        let put msg = hPutStrLn h msg
-        put $ ":- module(" ++ mod ++ ", [step/1, lemma/1])."
-        put ":- discontiguous(step/1)."
-        put ":- discontiguous(lemma/1)."
-        put ":- style_check(-singleton)."
-        return $ \msg -> hPutStrLn h msg
-  
-  let
-    say msg = unless (quiet globals) (putStrLn msg)
-    line = say ""
-    output = Output {
-      output_message = \msg -> do
-        say (prettyShow msg)
-        sayTrace (show (traceMsg msg)) }
-
-    traceMsg (NewActive active) =
-      step "add" [traceActive active]
-    traceMsg (NewEquation eqn) =
-      step "hard" [traceEqn eqn]
-    traceMsg (DeleteActive active) =
-      step "delete" [traceActive active]
-    traceMsg SimplifyQueue =
-      step "simplify_queue" []
-    traceMsg Interreduce =
-      step "interreduce" []
-
-    traceActive Active{..} =
-      traceApp "rule" [pPrint active_id, traceEqn (unorient active_rule)]
-    traceEqn (t :=: u) =
-      pPrintPrec prettyNormal 6 t <+> text "=" <+> pPrintPrec prettyNormal 6 u
-    traceApp f xs =
-      pPrintTerm uncurried prettyNormal 0 (text f) xs
-
-    step :: String -> [Doc] -> Doc
-    step f xs = traceApp "step" [traceApp f xs] <> text "."
-
-  say "Here is the input problem:"
-  forM_ axioms $ \Axiom{..} ->
-    say $ show $ nest 2 $
-      describeEquation "Axiom"
-        (show axiom_number) (Just axiom_name) axiom_eqn
-  forM_ goals $ \Goal{..} ->
-    say $ show $ nest 2 $
-      describeEquation "Goal"
-        (show goal_number) (Just goal_name) goal_eqn
-  line
-
-  state <- complete output config withAxioms
-  line
-
-  when (solved state && flags_proof main) $ later $ do
-    let
-      pres = present (cfg_proof_presentation config) (solutions state)
-
-    sayTrace ""
-    forM_ (pres_lemmas pres) $ \Lemma{..} ->
-      sayTrace $ show $
-        traceApp "lemma" [traceEqn (equation lemma_proof)] <> text "."
-
-    when tstp $ do
-      putStrLn "% SZS output start CNFRefutation"
-      print $ pPrintProof $
-        presentToJukebox ctx (curry toEquation)
-          (zip (map axiom_number axioms) (map pre_form axioms0))
-          (zip (map goal_number goals) (map pre_form goals0))
-          pres
-      putStrLn "% SZS output end CNFRefutation"
-      putStrLn ""
-
-    putStrLn "The conjecture is true! Here is a proof."
-    putStrLn ""
-    print $ pPrintPresentation (cfg_proof_presentation config) pres
-    putStrLn ""
-
-  when (not (quiet globals) && not (solved state)) $ later $ do
-    let
-      state' = interreduce config state
-      score rule =
-        (size (lhs rule), lhs rule,
-         size (rhs rule), rhs rule)
-      actives =
-        sortBy (comparing (score . active_rule)) $
-        IntMap.elems (st_active_ids state')
-
-    when (tstp && configIsComplete config) $ do
-      putStrLn "% SZS output start Saturation"
-      print $ pPrintProof $
-        map pre_form axioms0 ++
-        map pre_form goals0 ++
-        [ Input "rule" (Jukebox.Ax Jukebox.Axiom) Unknown $
-            toForm $ clause
-              [Pos (jukeboxTerm ctx (lhs rule) Jukebox.:=: jukeboxTerm ctx (rhs rule))]
-        | rule <- rules state ]
-      putStrLn "% SZS output end Saturation"
-      putStrLn ""
-
-    if configIsComplete config then do
-      putStrLn "Ran out of critical pairs. This means the conjecture is not true."
-    else do
-      putStrLn "Gave up on reaching the given resource limit."
-    putStrLn "Here is the final rewrite system:"
-    forM_ actives $ \active ->
-      putStrLn ("  " ++ prettyShow (canonicalise (active_rule active)))
-    putStrLn ""
-
-  return $
-    if solved state then Unsat Unsatisfiable Nothing
-    else if configIsComplete config then Sat Satisfiable Nothing
-    else NoAnswer GaveUp
-
--- Transform a proof presentation into a Jukebox proof.
-presentToJukebox ::
-  TweeContext ->
-  (Jukebox.Term -> Jukebox.Term -> Equation (Extended Constant)) ->
-  -- Axioms, indexed by axiom number.
-  [(Int, Input Form)] ->
-  -- N.B. the formula here proves the negated goal.
-  [(Int, Input Form)] ->
-  Presentation (Extended Constant) ->
-  Problem Form
-presentToJukebox ctx toEquation axioms goals Presentation{..} =
-  [ Input {
-      tag = pg_name,
-      kind = Jukebox.Ax Jukebox.Axiom,
-      what = false,
-      source =
-        Inference "resolution" "thm"
-          [-- A proof of t != u
-           existentialHack pg_goal_hint (fromJust (lookup pg_number goals)),
-           -- A proof of t = u
-           fromJust (Map.lookup pg_number goal_proofs)] }
-  | ProvedGoal{..} <- pres_goals ]
-
-  where
-    axiom_proofs =
-      Map.fromList
-        [ (axiom_number, fromJust (lookup axiom_number axioms))
-        | Axiom{..} <- pres_axioms ]
-
-    lemma_proofs =
-      Map.fromList [(lemma_id, tstp lemma_proof) | Lemma{..} <- pres_lemmas]
-
-    goal_proofs =
-      Map.fromList [(pg_number, tstp pg_proof) | ProvedGoal{..} <- pres_goals]
-
-    tstp :: Proof (Extended Constant) -> Input Form
-    tstp = deriv . derivation
-
-    deriv :: Derivation (Extended Constant) -> Input Form
-    deriv p@(Trans q r) = derivFrom (deriv r:sources q) p
-    deriv p = derivFrom (sources p) p
-
-    derivFrom :: [Input Form] -> Derivation (Extended Constant) -> Input Form
-    derivFrom sources p =
-      Input {
-        tag = "step",
-        kind = Jukebox.Ax Jukebox.Axiom,
-        what = jukeboxEquation (equation (certify p)),
-        source =
-          Inference "rw" "thm" sources }
-
-    jukeboxEquation :: Equation (Extended Constant) -> Form
-    jukeboxEquation (t :=: u) =
-      toForm $ clause [Pos (jukeboxTerm ctx t Jukebox.:=: jukeboxTerm ctx u)]
-
-    sources :: Derivation (Extended Constant) -> [Input Form]
-    sources p =
-      [ fromJust (Map.lookup lemma_id lemma_proofs)
-      | Lemma{..} <- usortBy (comparing lemma_id) (usedLemmas p) ] ++
-      [ fromJust (Map.lookup axiom_number axiom_proofs)
-      | Axiom{..} <- usort (usedAxioms p) ]
-
-    -- An ugly hack: since Twee.Proof decodes $true = $false into a
-    -- proof of the existentially quantified goal, we need to do the
-    -- same decoding at the Jukebox level.
-    existentialHack eqn input =
-      case find input of
-        [] -> error $ "bug in TSTP output: can't fix up decoded existential"
-        (inp:_) -> inp
-        where
-          -- Check if this looks like the correct clause;
-          -- if not, try its ancestors.
-          find inp | ok inp = [inp]
-          find Input{source = Inference _ _ inps} =
-            concatMap find inps
-          find _ = []
-
-          ok inp =
-            case toClause (what inp) of
-              Nothing -> False
-              Just (Clause (Bind _ [Neg (t' Jukebox.:=: u')])) ->
-                let
-                  eqn' = toEquation t' u'
-                  ts = buildList [eqn_lhs eqn, eqn_rhs eqn]
-                  us = buildList [eqn_lhs eqn', eqn_rhs eqn']
-                in
-                  isJust (matchList ts us) && isJust (matchList us ts)
-
-main = do
-  hSetBuffering stdout LineBuffering
-  join . parseCommandLineWithExtraArgs
-    ["--no-conjunctive-conjectures", "--no-split"]
-    "Twee, an equational theorem prover" . version ("twee version " ++ VERSION_twee) $
-      globalFlags *> parseMainFlags *>
-      -- hack: get --quiet and --no-proof options to appear before --tstp
-      forAllFilesBox <*>
-        (readProblemBox =>>=
-         expert clausifyBox =>>=
-         forAllConjecturesBox <*>
-           (combine <$>
-             expert hornToUnitBox <*>
-             (toFormulasBox =>>=
-              expert (toFof <$> clausifyBox <*> pure (tags True)) =>>=
-              expert clausifyBox =>>= expert oneConjectureBox) <*>
-             (runTwee <$> globalFlags <*> tstpFlags <*> parseMainFlags <*> expert hornFlags <*> parseConfig <*> parsePrecedence)))
-  where
-    combine horn encode prove later prob = do
-      res <- horn prob
-      case res of
-        Left ans -> return ans
-        Right prob ->
-          encode prob >>= prove later
diff --git a/README.md b/README.md
new file mode 100644
--- /dev/null
+++ b/README.md
@@ -0,0 +1,25 @@
+This is twee, an equational theorem prover.
+
+The version in this git repository is likely to be unstable!
+To install the latest stable version, run:
+
+    cabal install twee
+
+If you have LLVM installed, you can get a slightly faster version by
+running:
+
+    cabal install twee -fllvm
+
+If you really want the latest unstable version, run
+`cabal install src/ .` in this repository. You will most likely need
+the latest git version of Jukebox, from
+https://github.com/nick8325/jukebox, too - and things may break from
+time to time.
+
+Afterwards, run `twee nameofproblem.p`. The problem should be in TPTP
+format (http://www.tptp.org). You can find a few examples in the
+`tests` directory. All axioms and conjectures must be equations, but
+you can freely use quantifiers. If it succeeds in proving your
+problem, twee will print a human-readable proof.
+
+For the official manual, see http://nick8325.github.io/twee.
diff --git a/executable/Main.hs b/executable/Main.hs
new file mode 100644
--- /dev/null
+++ b/executable/Main.hs
@@ -0,0 +1,626 @@
+{-# LANGUAGE CPP, RecordWildCards, FlexibleInstances, PatternGuards #-}
+import Control.Monad
+import Data.Char
+import Data.Either
+import Twee hiding (message)
+import Twee.Base hiding (char, lookup, vars)
+import Twee.Rule(lhs, rhs, unorient)
+import Twee.Equation
+import qualified Twee.Proof as Proof
+import Twee.Proof hiding (Config, defaultConfig)
+import qualified Twee.Join as Join
+import Twee.Utils
+import qualified Twee.CP as CP
+import Data.Ord
+import qualified Data.Map.Strict as Map
+import qualified Twee.KBO as KBO
+import Data.List.Split
+import Data.List
+import Data.Maybe
+import Jukebox.Options
+import Jukebox.Toolbox
+import Jukebox.Name hiding (lhs, rhs)
+import qualified Jukebox.Form as Jukebox
+import Jukebox.Form hiding ((:=:), Var, Symbolic(..), Term, Axiom, size, Lemma)
+import Jukebox.Tools.EncodeTypes
+import Jukebox.TPTP.Print
+import Jukebox.Tools.HornToUnit
+import qualified Data.IntMap.Strict as IntMap
+import System.IO
+import System.Exit
+import qualified Data.Set as Set
+import Twee.Label
+
+data MainFlags =
+  MainFlags {
+    flags_proof :: Bool,
+    flags_trace :: Maybe (String, String) }
+
+parseMainFlags :: OptionParser MainFlags
+parseMainFlags =
+  MainFlags <$> proof <*> trace
+  where
+    proof =
+      inGroup "Output options" $
+      bool "proof" ["Produce proofs (on by default)."]
+      True
+    trace =
+      expert $
+      inGroup "Output options" $
+      flag "trace"
+        ["Write a Prolog-format execution trace to this file (off by default)."]
+        Nothing ((\x y -> Just (x, y)) <$> argFile <*> argModule)
+    argModule = arg "<module>" "expected a Prolog module name" Just
+
+parseConfig :: OptionParser Config
+parseConfig =
+  Config <$> maxSize <*> maxCPs <*> maxCPDepth <*> simplify <*> normPercent <*>
+    (CP.Config <$> lweight <*> rweight <*> funweight <*> varweight <*> depthweight <*> dupcost <*> dupfactor) <*>
+    (Join.Config <$> ground_join <*> connectedness <*> set_join) <*>
+    (Proof.Config <$> all_lemmas <*> flat_proof <*> show_instances)
+  where
+    maxSize =
+      inGroup "Resource limits" $
+      flag "max-term-size" ["Discard rewrite rules whose left-hand side is bigger than this limit (unlimited by default)."] maxBound argNum
+    maxCPs =
+      inGroup "Resource limits" $
+      flag "max-cps" ["Give up after considering this many critical pairs (unlimited by default)."] maxBound argNum
+    maxCPDepth =
+      inGroup "Resource limits" $
+      flag "max-cp-depth" ["Only consider critical pairs up to this depth (unlimited by default)."] maxBound argNum
+    simplify =
+      expert $
+      inGroup "Completion heuristics" $
+      bool "simplify"
+        ["Simplify rewrite rules with respect to one another (on by default)."]
+        True
+    normPercent =
+      expert $
+      inGroup "Completion heuristics" $
+      defaultFlag "normalise-queue-percent" "Percent of time spent renormalising queued critical pairs" (cfg_renormalise_percent) argNum
+    lweight =
+      expert $
+      inGroup "Critical pair weighting heuristics" $
+      defaultFlag "lhs-weight" "Weight given to LHS of critical pair" (CP.cfg_lhsweight . cfg_critical_pairs) argNum
+    rweight =
+      expert $
+      inGroup "Critical pair weighting heuristics" $
+      defaultFlag "rhs-weight" "Weight given to RHS of critical pair" (CP.cfg_rhsweight . cfg_critical_pairs) argNum
+    funweight =
+      expert $
+      inGroup "Critical pair weighting heuristics" $
+      defaultFlag "fun-weight" "Weight given to function symbols" (CP.cfg_funweight . cfg_critical_pairs) argNum
+    varweight =
+      expert $
+      inGroup "Critical pair weighting heuristics" $
+      defaultFlag "var-weight" "Weight given to variable symbols" (CP.cfg_varweight . cfg_critical_pairs) argNum
+    depthweight =
+      expert $
+      inGroup "Critical pair weighting heuristics" $
+      defaultFlag "depth-weight" "Weight given to critical pair depth" (CP.cfg_depthweight . cfg_critical_pairs) argNum
+    dupcost =
+      expert $
+      inGroup "Critical pair weighting heuristics" $
+      defaultFlag "dup-cost" "Cost of duplicate subterms" (CP.cfg_dupcost . cfg_critical_pairs) argNum
+    dupfactor =
+      expert $
+      inGroup "Critical pair weighting heuristics" $
+      defaultFlag "dup-factor" "Size factor of duplicate subterms" (CP.cfg_dupfactor . cfg_critical_pairs) argNum
+    ground_join =
+      expert $
+      inGroup "Critical pair joining heuristics" $
+      bool "ground-joining"
+        ["Test terms for ground joinability (on by default)."]
+        True
+    connectedness =
+      expert $
+      inGroup "Critical pair joining heuristics" $
+      bool "connectedness"
+        ["Test terms for subconnectedness (on by default)."]
+        True
+    set_join =
+      expert $
+      inGroup "Critical pair joining heuristics" $
+      bool "set-join"
+        ["Compute all normal forms when joining critical pairs (off by default)."]
+        False
+    all_lemmas =
+      expert $
+      inGroup "Proof presentation" $
+      bool "all-lemmas"
+        ["Produce a proof with one lemma for each critical pair (off by default)."]
+        False
+    flat_proof =
+      expert $
+      inGroup "Proof presentation" $
+      bool "no-lemmas"
+        ["Produce a proof with no lemmas (off by default).",
+         "May lead to exponentially large proofs."]
+        False
+    show_instances =
+      expert $
+      inGroup "Proof presentation" $
+      bool "show-instances"
+        ["Show which instances of each axiom and lemma were used (off by default)."]
+        False
+    defaultFlag name desc field parser =
+      flag name [desc ++ " (" ++ show def ++ " by default)."] def parser
+      where
+        def = field defaultConfig
+
+parsePrecedence :: OptionParser [String]
+parsePrecedence =
+  expert $
+  inGroup "Term order options" $
+  fmap (splitOn ",")
+  (flag "precedence" ["List of functions in descending order of precedence."] [] (arg "<function>" "expected a function name" Just))
+
+data Constant =
+  Constant {
+    con_prec  :: {-# UNPACK #-} !Precedence,
+    con_id    :: {-# UNPACK #-} !Jukebox.Function,
+    con_arity :: {-# UNPACK #-} !Int,
+    con_size  :: {-# UNPACK #-} !Int,
+    con_bonus :: !Bool }
+  deriving (Eq, Ord)
+
+data Precedence = Precedence !Bool !Bool !(Maybe Int) !Int
+  deriving (Eq, Ord)
+
+instance Sized Constant where
+  size Constant{..} = con_size
+instance Arity Constant where
+  arity Constant{..} = con_arity
+
+instance Pretty Constant where
+  pPrint Constant{..} = text (base con_id)
+
+instance PrettyTerm Constant where
+  termStyle Constant{..}
+    | "$to_" `isPrefixOf` (base con_id) = invisible
+    | any isAlphaNum (base con_id) = uncurried
+    | otherwise =
+      case con_arity of
+        1 -> prefix
+        2 -> infixStyle 5
+        _ -> uncurried
+
+instance Ordered (Extended Constant) where
+  lessEq t u = {-# SCC lessEq #-} KBO.lessEq t u
+  lessIn model t u = {-# SCC lessIn #-} KBO.lessIn model t u
+
+instance EqualsBonus Constant where
+  hasEqualsBonus = con_bonus
+  isEquals = Main.isEquals . con_id
+  isTrue = Main.isTrue . con_id
+  isFalse = Main.isFalse . con_id
+
+data TweeContext =
+  TweeContext {
+    ctx_var     :: Jukebox.Variable,
+    ctx_minimal :: Jukebox.Function,
+    ctx_true    :: Jukebox.Function,
+    ctx_false   :: Jukebox.Function,
+    ctx_equals  :: Jukebox.Function,
+    ctx_type    :: Type }
+
+-- Convert back and forth between Twee and Jukebox.
+tweeConstant :: HornFlags -> TweeContext -> Precedence -> Jukebox.Function -> Extended Constant
+tweeConstant flags TweeContext{..} prec fun
+  | fun == ctx_minimal = Minimal
+  | otherwise = Function (Constant prec fun (Jukebox.arity fun) (sz fun) (bonus fun))
+  where
+    sz fun = if isType fun then 0 else 1
+    bonus fun =
+      (isIfeq fun && encoding flags /= Asymmetric2) ||
+      Main.isEquals fun
+
+isType :: Jukebox.Function -> Bool
+isType fun = "$to_" `isPrefixOf` base (name fun)
+
+isIfeq :: Jukebox.Function -> Bool
+isIfeq fun = "$ifeq" `isPrefixOf` base (name fun)
+
+isEquals :: Jukebox.Function -> Bool
+isEquals fun = "$equals" `isPrefixOf` base (name fun)
+
+isTrue :: Jukebox.Function -> Bool
+isTrue fun = "$true" `isPrefixOf` base (name fun)
+
+isFalse :: Jukebox.Function -> Bool
+isFalse fun = "$false" `isPrefixOf` base (name fun)
+
+jukeboxFunction :: TweeContext -> Extended Constant -> Jukebox.Function
+jukeboxFunction _ (Function Constant{..}) = con_id
+jukeboxFunction TweeContext{..} Minimal = ctx_minimal
+jukeboxFunction TweeContext{..} (Skolem _) =
+  error "Skolem variable leaked into rule"
+
+tweeTerm :: HornFlags -> TweeContext -> (Jukebox.Function -> Precedence) -> Jukebox.Term -> Term (Extended Constant)
+tweeTerm flags ctx prec t = build (tm t)
+  where
+    tm (Jukebox.Var (x ::: _)) =
+      var (V (fromIntegral (labelNum (label x))))
+    tm (f :@: ts) =
+      app (fun (tweeConstant flags ctx (prec f) f)) (map tm ts)
+
+jukeboxTerm :: TweeContext -> Term (Extended Constant) -> Jukebox.Term
+jukeboxTerm TweeContext{..} (Var (V x)) =
+  Jukebox.Var (Unique (fromIntegral x) "X" defaultRenamer ::: ctx_type)
+jukeboxTerm ctx@TweeContext{..} (App f t) =
+  jukeboxFunction ctx (fun_value f) :@: map (jukeboxTerm ctx) ts
+  where
+    ts = unpack t
+
+makeContext :: Problem Clause -> TweeContext
+makeContext prob = run prob $ \prob -> do
+  let
+    ty =
+      case types' prob of
+        []   -> indType
+        [ty] -> ty
+
+  var     <- newSymbol "X" ty
+  minimal <- newFunction "$constant" [] ty
+  true    <- newFunction "$true" [] ty
+  false   <- newFunction "$false" [] ty
+  equals  <- newFunction "$equals" [ty, ty] ty
+
+  return TweeContext {
+    ctx_var = var,
+    ctx_minimal = minimal,
+    ctx_true = true,
+    ctx_false = false,
+    ctx_equals = equals,
+    ctx_type = ty }
+
+-- Encode existentials so that all goals are ground.
+addNarrowing :: TweeContext -> Problem Clause -> Problem Clause
+addNarrowing TweeContext{..} prob =
+  unchanged ++ equalityClauses
+  where
+    (unchanged, nonGroundGoals) = partitionEithers (map f prob)
+      where
+        f inp@Input{what = Clause (Bind _ [Neg (x Jukebox.:=: y)])}
+          | not (ground x) || not (ground y) =
+            Right (inp, (x, y))
+        f inp = Left inp
+
+    equalityClauses
+      | null nonGroundGoals = []
+      | otherwise =
+        -- Turn a != b & c != d & ...
+        -- into eq(a,b)=false & eq(c,d)=false & eq(X,X)=true & true!=false (esa)
+        -- and then extract the individual components (thm)
+        let
+          equalityLiterals =
+            -- true != false
+            ("true_equals_false", Neg ((ctx_true :@:) [] Jukebox.:=: (ctx_false :@: []))):
+            -- eq(X,X)=true
+            ("reflexivity", Pos (ctx_equals :@: [Jukebox.Var ctx_var, Jukebox.Var ctx_var] Jukebox.:=: (ctx_true :@: []))):
+            -- [eq(a,b)=false, eq(c,d)=false, ...]
+            [ (tag, Pos (ctx_equals :@: [x, y] Jukebox.:=: (ctx_false :@: [])))
+            | (Input{tag = tag}, (x, y)) <- nonGroundGoals ]
+
+          -- Equisatisfiable to the input clauses
+          justification =
+            Input {
+              tag  = "new_negated_conjecture",
+              kind = Jukebox.Ax NegatedConjecture,
+              what =
+                let form = And (map (Literal . snd) equalityLiterals) in
+                ForAll (Bind (Set.fromList (vars form)) form),
+              source =
+                Inference "encode_existential" "esa"
+                  (map (fmap toForm . fst) nonGroundGoals) }
+
+          input tag form =
+            Input {
+              tag = tag,
+              kind = Conj Conjecture,
+              what = clause [form],
+              source =
+                Inference "split_conjunct" "thm" [justification] }
+
+        in [input tag form | (tag, form) <- equalityLiterals]
+
+data PreEquation =
+  PreEquation {
+    pre_name :: String,
+    pre_form :: Input Form,
+    pre_eqn  :: (Jukebox.Term, Jukebox.Term) }
+
+-- Split the problem into axioms and ground goals.
+identifyProblem ::
+  TweeContext -> Problem Clause -> Either (Input Clause) ([PreEquation], [PreEquation])
+identifyProblem TweeContext{..} prob =
+  fmap partitionEithers (mapM identify prob)
+
+  where
+    pre inp x =
+      PreEquation {
+        pre_name = tag inp,
+        pre_form = fmap toForm inp,
+        pre_eqn = x }
+
+    identify inp@Input{what = Clause (Bind _ [Pos (t Jukebox.:=: u)])} =
+      return $ Left (pre inp (t, u))
+    identify inp@Input{what = Clause (Bind _ [Neg (t Jukebox.:=: u)])}
+      | ground t && ground u =
+        return $ Right (pre inp (t, u))
+    identify inp@Input{what = Clause (Bind _ [])} =
+      -- The empty clause can appear after clausification if
+      -- the conjecture was trivial
+      return $ Left (pre inp (Jukebox.Var ctx_var, ctx_minimal :@: []))
+    identify inp = Left inp
+
+runTwee :: GlobalFlags -> TSTPFlags -> MainFlags -> HornFlags -> Config -> [String] -> (IO () -> IO ()) -> Problem Clause -> IO Answer
+runTwee globals (TSTPFlags tstp) main horn config precedence later obligs = {-# SCC runTwee #-} do
+  let
+    -- Encode whatever needs encoding in the problem
+    ctx = makeContext obligs
+    prob = addNarrowing ctx obligs
+
+  (axioms0, goals0) <-
+    case identifyProblem ctx prob of
+      Left inp -> do
+        mapM_ (hPutStrLn stderr) [
+          "The problem contains the following clause, which is not a unit equality:",
+          indent (show (pPrintClauses [inp])),
+          "Twee only handles unit equality problems."]
+        exitWith (ExitFailure 1)
+      Right x -> return x
+
+  let
+    -- Work out a precedence for function symbols
+    prec c =
+      Precedence
+        (isType c)
+        (isNothing (elemIndex (base c) precedence))
+        (fmap negate (elemIndex (base c) precedence))
+        (negate (Map.findWithDefault 0 c occs))
+    occs = funsOcc prob
+
+    -- Translate everything to Twee.
+    toEquation (t, u) =
+      canonicalise (tweeTerm horn ctx prec t :=: tweeTerm horn ctx prec u)
+
+    goals =
+      [ goal n pre_name (toEquation pre_eqn)
+      | (n, PreEquation{..}) <- zip [1..] goals0 ]
+    axioms =
+      [ Axiom n pre_name (toEquation pre_eqn)
+      | (n, PreEquation{..}) <- zip [1..] axioms0 ]
+
+    withGoals = foldl' (addGoal config) initialState goals
+    withAxioms = foldl' (addAxiom config) withGoals axioms
+
+  -- Set up tracing.
+  sayTrace <-
+    case flags_trace main of
+      Nothing -> return $ \_ -> return ()
+      Just (file, mod) -> do
+        h <- openFile file WriteMode
+        hSetBuffering h LineBuffering
+        let put msg = hPutStrLn h msg
+        put $ ":- module(" ++ mod ++ ", [step/1, lemma/1])."
+        put ":- discontiguous(step/1)."
+        put ":- discontiguous(lemma/1)."
+        put ":- style_check(-singleton)."
+        return $ \msg -> hPutStrLn h msg
+  
+  let
+    say msg = unless (quiet globals) (putStrLn msg)
+    line = say ""
+    output = Output {
+      output_message = \msg -> do
+        say (prettyShow msg)
+        sayTrace (show (traceMsg msg)) }
+
+    traceMsg (NewActive active) =
+      step "add" [traceActive active]
+    traceMsg (NewEquation eqn) =
+      step "hard" [traceEqn eqn]
+    traceMsg (DeleteActive active) =
+      step "delete" [traceActive active]
+    traceMsg SimplifyQueue =
+      step "simplify_queue" []
+    traceMsg Interreduce =
+      step "interreduce" []
+
+    traceActive Active{..} =
+      traceApp "rule" [pPrint active_id, traceEqn (unorient active_rule)]
+    traceEqn (t :=: u) =
+      pPrintPrec prettyNormal 6 t <+> text "=" <+> pPrintPrec prettyNormal 6 u
+    traceApp f xs =
+      pPrintTerm uncurried prettyNormal 0 (text f) xs
+
+    step :: String -> [Doc] -> Doc
+    step f xs = traceApp "step" [traceApp f xs] <> text "."
+
+  say "Here is the input problem:"
+  forM_ axioms $ \Axiom{..} ->
+    say $ show $ nest 2 $
+      describeEquation "Axiom"
+        (show axiom_number) (Just axiom_name) axiom_eqn
+  forM_ goals $ \Goal{..} ->
+    say $ show $ nest 2 $
+      describeEquation "Goal"
+        (show goal_number) (Just goal_name) goal_eqn
+  line
+
+  state <- complete output config withAxioms
+  line
+
+  when (solved state && flags_proof main) $ later $ do
+    let
+      pres = present (cfg_proof_presentation config) (solutions state)
+
+    sayTrace ""
+    forM_ (pres_lemmas pres) $ \Lemma{..} ->
+      sayTrace $ show $
+        traceApp "lemma" [traceEqn (equation lemma_proof)] <> text "."
+
+    when tstp $ do
+      putStrLn "% SZS output start CNFRefutation"
+      print $ pPrintProof $
+        presentToJukebox ctx (curry toEquation)
+          (zip (map axiom_number axioms) (map pre_form axioms0))
+          (zip (map goal_number goals) (map pre_form goals0))
+          pres
+      putStrLn "% SZS output end CNFRefutation"
+      putStrLn ""
+
+    putStrLn "The conjecture is true! Here is a proof."
+    putStrLn ""
+    print $ pPrintPresentation (cfg_proof_presentation config) pres
+    putStrLn ""
+
+  when (not (quiet globals) && not (solved state)) $ later $ do
+    let
+      state' = interreduce config state
+      score rule =
+        (size (lhs rule), lhs rule,
+         size (rhs rule), rhs rule)
+      actives =
+        sortBy (comparing (score . active_rule)) $
+        IntMap.elems (st_active_ids state')
+
+    when (tstp && configIsComplete config) $ do
+      putStrLn "% SZS output start Saturation"
+      print $ pPrintProof $
+        map pre_form axioms0 ++
+        map pre_form goals0 ++
+        [ Input "rule" (Jukebox.Ax Jukebox.Axiom) Unknown $
+            toForm $ clause
+              [Pos (jukeboxTerm ctx (lhs rule) Jukebox.:=: jukeboxTerm ctx (rhs rule))]
+        | rule <- rules state ]
+      putStrLn "% SZS output end Saturation"
+      putStrLn ""
+
+    if configIsComplete config then do
+      putStrLn "Ran out of critical pairs. This means the conjecture is not true."
+    else do
+      putStrLn "Gave up on reaching the given resource limit."
+    putStrLn "Here is the final rewrite system:"
+    forM_ actives $ \active ->
+      putStrLn ("  " ++ prettyShow (canonicalise (active_rule active)))
+    putStrLn ""
+
+  return $
+    if solved state then Unsat Unsatisfiable Nothing
+    else if configIsComplete config then Sat Satisfiable Nothing
+    else NoAnswer GaveUp
+
+-- Transform a proof presentation into a Jukebox proof.
+presentToJukebox ::
+  TweeContext ->
+  (Jukebox.Term -> Jukebox.Term -> Equation (Extended Constant)) ->
+  -- Axioms, indexed by axiom number.
+  [(Int, Input Form)] ->
+  -- N.B. the formula here proves the negated goal.
+  [(Int, Input Form)] ->
+  Presentation (Extended Constant) ->
+  Problem Form
+presentToJukebox ctx toEquation axioms goals Presentation{..} =
+  [ Input {
+      tag = pg_name,
+      kind = Jukebox.Ax Jukebox.Axiom,
+      what = false,
+      source =
+        Inference "resolution" "thm"
+          [-- A proof of t != u
+           existentialHack pg_goal_hint (fromJust (lookup pg_number goals)),
+           -- A proof of t = u
+           fromJust (Map.lookup pg_number goal_proofs)] }
+  | ProvedGoal{..} <- pres_goals ]
+
+  where
+    axiom_proofs =
+      Map.fromList
+        [ (axiom_number, fromJust (lookup axiom_number axioms))
+        | Axiom{..} <- pres_axioms ]
+
+    lemma_proofs =
+      Map.fromList [(lemma_id, tstp lemma_proof) | Lemma{..} <- pres_lemmas]
+
+    goal_proofs =
+      Map.fromList [(pg_number, tstp pg_proof) | ProvedGoal{..} <- pres_goals]
+
+    tstp :: Proof (Extended Constant) -> Input Form
+    tstp = deriv . derivation
+
+    deriv :: Derivation (Extended Constant) -> Input Form
+    deriv p@(Trans q r) = derivFrom (deriv r:sources q) p
+    deriv p = derivFrom (sources p) p
+
+    derivFrom :: [Input Form] -> Derivation (Extended Constant) -> Input Form
+    derivFrom sources p =
+      Input {
+        tag = "step",
+        kind = Jukebox.Ax Jukebox.Axiom,
+        what = jukeboxEquation (equation (certify p)),
+        source =
+          Inference "rw" "thm" sources }
+
+    jukeboxEquation :: Equation (Extended Constant) -> Form
+    jukeboxEquation (t :=: u) =
+      toForm $ clause [Pos (jukeboxTerm ctx t Jukebox.:=: jukeboxTerm ctx u)]
+
+    sources :: Derivation (Extended Constant) -> [Input Form]
+    sources p =
+      [ fromJust (Map.lookup lemma_id lemma_proofs)
+      | Lemma{..} <- usortBy (comparing lemma_id) (usedLemmas p) ] ++
+      [ fromJust (Map.lookup axiom_number axiom_proofs)
+      | Axiom{..} <- usort (usedAxioms p) ]
+
+    -- An ugly hack: since Twee.Proof decodes $true = $false into a
+    -- proof of the existentially quantified goal, we need to do the
+    -- same decoding at the Jukebox level.
+    existentialHack eqn input =
+      case find input of
+        [] -> error $ "bug in TSTP output: can't fix up decoded existential"
+        (inp:_) -> inp
+        where
+          -- Check if this looks like the correct clause;
+          -- if not, try its ancestors.
+          find inp | ok inp = [inp]
+          find Input{source = Inference _ _ inps} =
+            concatMap find inps
+          find _ = []
+
+          ok inp =
+            case toClause (what inp) of
+              Nothing -> False
+              Just (Clause (Bind _ [Neg (t' Jukebox.:=: u')])) ->
+                let
+                  eqn' = toEquation t' u'
+                  ts = buildList [eqn_lhs eqn, eqn_rhs eqn]
+                  us = buildList [eqn_lhs eqn', eqn_rhs eqn']
+                in
+                  isJust (matchList ts us) && isJust (matchList us ts)
+
+main = do
+  hSetBuffering stdout LineBuffering
+  join . parseCommandLineWithExtraArgs
+    ["--no-conjunctive-conjectures", "--no-split"]
+    "Twee, an equational theorem prover" . version ("twee version " ++ VERSION_twee) $
+      globalFlags *> parseMainFlags *>
+      -- hack: get --quiet and --no-proof options to appear before --tstp
+      forAllFilesBox <*>
+        (readProblemBox =>>=
+         expert clausifyBox =>>=
+         forAllConjecturesBox <*>
+           (combine <$>
+             expert hornToUnitBox <*>
+             (toFormulasBox =>>=
+              expert (toFof <$> clausifyBox <*> pure (tags True)) =>>=
+              expert clausifyBox =>>= expert oneConjectureBox) <*>
+             (runTwee <$> globalFlags <*> tstpFlags <*> parseMainFlags <*> expert hornFlags <*> parseConfig <*> parsePrecedence)))
+  where
+    combine horn encode prove later prob = do
+      res <- horn prob
+      case res of
+        Left ans -> return ans
+        Right prob ->
+          encode prob >>= prove later
diff --git a/misc/analyse_trace.pl b/misc/analyse_trace.pl
new file mode 100644
--- /dev/null
+++ b/misc/analyse_trace.pl
@@ -0,0 +1,32 @@
+:- use_module(boo067_good, []).
+:- use_module(boo067_bad, []).
+
+ground(Pred, X) :-
+	call(Pred, Y),
+	numbervars(Y, 1, _),
+	X=Y.
+
+default(Pred, X) :-
+    call(Pred, boo067_good, boo067_bad, X).
+
+missing(X) :- default(missing, X).
+missing(Good, Bad, X) :-
+	ground(Good:lemma, X),
+	\+ found(Bad, add(rule(_, X))).
+
+variant(rule(N, X=Y), rule(N, X=Y)).
+variant(rule(N, X=Y), rule(N, Y=X)).
+
+found(Mod, Rule) :-
+	variant(Rule, Rule1),
+	Mod:step(add(Rule1)).
+
+gone(Mod, rule(N, X)) :-
+	ground(Mod:lemma, X),
+	found(Mod, rule(N, X)),
+	Mod:step(delete(N)).
+
+reappeared(Mod, rule(N, X), M) :-
+	ground(found(Mod), rule(N, X)),
+	found(Mod, rule(M, X)),
+	M > N.
diff --git a/misc/bench.hs b/misc/bench.hs
new file mode 100644
--- /dev/null
+++ b/misc/bench.hs
@@ -0,0 +1,74 @@
+{-# LANGUAGE PatternGuards, FlexibleInstances #-}
+import Criterion.Main
+import Twee.Term hiding (isFun)
+import qualified Twee.Term
+import Test.QuickCheck
+import Data.Int
+import Data.Maybe
+import Twee.Term.Core hiding (subst)
+
+instance Num (Fun Int) where fromInteger n = F (fromInteger n) (fromInteger n)
+instance Num Var where fromInteger = V . fromInteger
+
+t0, t1, u0, u1, t2, t, u :: Term Int
+t0 = build $ fun 0 [var 0, fun 0 [var 0, fun 0 [fun 0 [var 0, var 1], var 2]]]
+u0 = build $ fun 0 [fun 0 [fun 2 [fun 2 [var 2, var 2], var 1], fun 0 [fun 2 [var 2, var 2], var 3]], fun 0 [fun 0 [fun 2 [fun 2 [var 2, var 2], var 1], fun 0 [fun 2 [var 2, var 2], var 3]], fun 0 [fun 0 [fun 0 [fun 2 [fun 2 [var 2, var 2], var 1], fun 0 [fun 2 [var 2, var 2], var 3]], fun 2 [fun 2 [var 2, var 2], var 1]], fun 2 [var 2, var 2]]]]
+
+t1 = build $ fun 0 [fun 1 [var 0], fun 1 [var 1]]
+u1 = build $ fun 0 [fun 1 [fun 0 [fun 2 emptyTermList, fun 3 emptyTermList]], fun 1 [fun 0 [fun 4 emptyTermList, fun 5 emptyTermList]]]
+
+t2 = build $ fun 0 [var 0, fun 1 [var 1, fun 1 [var 1, var 1]]]
+u2 = build $ fun 0 [fun 0 [var 2, var 2], var 2]
+
+t = t0
+u = u0
+
+Just sub = match t u
+
+mgu1 t u = let Just sub = unifyTri t u in build (subst sub t)
+mgu2 t u = let Just sub = unify t u in build (subst sub t)
+
+Just sub' = unifyTri t2 u2
+Just csub' = unify t2 u2
+
+main = do
+  print t
+  print u
+  print (match t u)
+  print (build (subst sub t))
+  print (unifyTri t2 u2)
+  print (close sub')
+  print (build (subst sub' t2))
+  print (build (subst sub' u2))
+  print (mgu1 t2 u2)
+  print (mgu2 t2 u2)
+  print (t == t)
+  print (build (subst sub t) == u)
+  print (build (subst sub' t2) == build (subst sub' u2))
+  print (build (subst csub' t1) == build (subst sub' t1))
+  print (mgu1 t2 u2 == mgu2 t2 u2)
+  print (build (subst csub' t2) == build (subst sub' t2))
+  defaultMain [
+    bench "eq-t" (whnf (uncurry (==)) (t, t)),
+    bench "eq-u" (whnf (uncurry (==)) (u, u)),
+    bench "match" (whnf (fromJust . uncurry match) (t, u)),
+    bench "subst" (whnf (build . uncurry subst) (sub, t)),
+    bench "unifyTri" (whnf (fromJust . uncurry unifyTri) (t2, u2)),
+    bench "unify-close" (whnf (uncurry unify) (t2, u2)),
+    bench "unify-subst-iter1" (whnf (build . uncurry subst) (sub', t2)),
+    bench "unify-subst-iter2" (whnf (build . uncurry subst) (sub', u2)),
+    bench "unify-subst-closed1" (whnf (build . uncurry subst) (csub', t2)),
+    bench "unify-subst-closed2" (whnf (build . uncurry subst) (csub', u2)),
+    bench "mgu-tri" (whnf (uncurry mgu1) (t2, u2)),
+    bench "mgu-close" (whnf (uncurry mgu2) (t2, u2)),
+    bench "make-constant" (whnf (build . uncurry fun) (F 0 0, emptyTermList)),
+    bench "baseline" (whnf (uncurry (+)) (0 :: Int, 0))]
+
+prop :: Bool -> NonNegative (Small Int) -> NonNegative (Small Int) -> Property
+prop fun_ (NonNegative (Small index_)) (NonNegative (Small size_)) =
+  (isFun x, index x, size x) === (fun_, index_, size_)
+  where
+    x = toSymbol (fromSymbol (Symbol fun_ index_ size_))
+
+prop2 :: Int64 -> Property
+prop2 x = fromSymbol (toSymbol x) === x
diff --git a/misc/ring_conn.pl b/misc/ring_conn.pl
new file mode 100644
--- /dev/null
+++ b/misc/ring_conn.pl
@@ -0,0 +1,801 @@
+:- module(ring_conn, [step/1, lemma/1]).
+:- discontiguous(step/1).
+:- discontiguous(lemma/1).
+:- style_check(-singleton).
+step(add(rule(1, (X1 + X2) = (X2 + X1)))).
+step(add(rule(2, ((X1 + X2) + X3) = (X1 + (X2 + X3))))).
+step(add(rule(3, (0 + X1) = X1))).
+step(add(rule(4, (X1 + -X1) = 0))).
+step(add(rule(5, ((X1 * X2) * X3) = (X1 * (X2 * X3))))).
+step(add(rule(6, ((X1 * X2) + (X1 * X3)) = (X1 * (X2 + X3))))).
+step(add(rule(7, ((X1 * X3) + (X2 * X3)) = ((X1 + X2) * X3)))).
+step(add(rule(8, (X1 * (X1 * X1)) = X1))).
+step(add(rule(9, -0 = 0))).
+step(add(rule(10, (X1 + 0) = X1))).
+step(add(rule(11, (X1 + (-X1 + X2)) = X2))).
+step(add(rule(12, -(-X1) = X1))).
+step(add(rule(13, (X1 + (X2 + X3)) = (X3 + (X1 + X2))))).
+step(add(rule(14, (X1 + (X2 + X3)) = (X2 + (X1 + X3))))).
+step(add(rule(15, ((X1 + X1) * X2) = (X1 * (X2 + X2))))).
+step(add(rule(16, (X2 + (X1 + -X2)) = X1))).
+step(add(rule(17, (0 * (X1 + X1)) = (0 * X1)))).
+step(add(rule(18, (X1 * (X1 * (X1 * X2))) = (X1 * X2)))).
+step(hard((X1 + (X2 + X3)) = (X3 + (X2 + X1)))).
+step(hard((X1 + (X2 + X3)) = (X1 + (X3 + X2)))).
+step(add(rule(19, (X1 + (X2 + -(X1 + X2))) = 0))).
+step(add(rule(20, (X1 + -(-X2 + X1)) = X2))).
+step(add(rule(21, (X1 * ((X1 * X1) + X2)) = (X1 + (X1 * X2))))).
+step(add(rule(22, (X1 + (X1 * 0)) = X1))).
+step(add(rule(23, (X1 * 0) = 0))).
+step(add(rule(24, (X1 * (X2 + (X1 * X1))) = (X1 + (X1 * X2))))).
+step(add(rule(25, (X2 + -(X1 + X2)) = -X1))).
+step(add(rule(26, ((X1 + X1) * (X1 * X1)) = (X1 + X1)))).
+step(hard(0 = (X1 + (X2 + -(X2 + X1))))).
+step(add(rule(27, (X2 + -(X2 + -X1)) = X1))).
+step(add(rule(28, -(-X1 + -X2) = (X2 + X1)))).
+step(add(rule(29, (X1 * (0 * X2)) = (0 * X2)))).
+step(add(rule(30, (X1 + (X2 * (X1 * X1))) = ((X1 + X2) * (X1 * X1))))).
+step(add(rule(31, (X2 + -(X2 + X1)) = -X1))).
+step(hard((-X1 + (X2 + (X3 + X1))) = (X3 + X2))).
+step(add(rule(32, (X3 + (X2 + (-X3 + X1))) = (X1 + X2)))).
+step(add(rule(33, (X3 + (X1 + (X2 + -X3))) = (X1 + X2)))).
+step(add(rule(34, -(X1 + -X2) = (X2 + -X1)))).
+step(add(rule(35, (-X1 + -X2) = -(X2 + X1)))).
+step(add(rule(36, (X1 + (X1 * -(X1 * X1))) = 0))).
+step(add(rule(37, (-X1 * -(-X1 * -X1)) = X1))).
+step(add(rule(38, (-X1 * (-X1 * X1)) = X1))).
+step(add(rule(39, (X1 * -(X1 * X1)) = -X1))).
+step(hard((X1 + (X2 + (X3 + X4))) = (X2 + (X3 + (X4 + X1))))).
+step(hard((X1 + (X2 + (X3 + X4))) = (X3 + (X2 + (X4 + X1))))).
+step(hard((X1 + (X2 + (X3 + X4))) = (X3 + (X4 + (X1 + X2))))).
+step(hard((X1 + (X2 + (X3 + X4))) = (X4 + (X3 + (X1 + X2))))).
+step(hard((X1 + (X2 + (X3 + X4))) = (X3 + (X1 + (X2 + X4))))).
+step(hard((X1 + (X2 + (X3 + X4))) = (X4 + (X2 + (X3 + X1))))).
+step(hard((X1 + (X2 + (X3 + X4))) = (X2 + (X4 + (X1 + X3))))).
+step(add(rule(40, ((X1 + X1) * (X2 * X3)) = (X1 * ((X2 + X2) * X3))))).
+step(add(rule(41, (X1 * (X1 * (X1 + X1))) = (X1 + X1)))).
+step(add(rule(42, (X1 * (X2 * (X3 + X3))) = (X1 * ((X2 + X2) * X3))))).
+step(add(rule(43, (X1 + (X1 * (X1 * X2))) = (X1 * (X1 * (X1 + X2)))))).
+step(add(rule(44, (X1 + (X1 * (X2 * X1))) = (X1 * ((X1 + X2) * X1))))).
+step(add(rule(45, (X1 + (0 * X1)) = X1))).
+step(add(rule(46, (0 * X1) = 0))).
+step(add(rule(47, (X2 + (X3 + (-(X2 + X3) + X1))) = X1))).
+step(hard((X1 + (X2 + (-(X2 + X1) + X3))) = X3)).
+step(add(rule(48, (X1 * (X1 * -X1)) = -X1))).
+step(add(rule(49, -(-X1 + X2) = (X1 + -X2)))).
+step(add(rule(50, ((X1 * X2) + ((X1 * X3) + X4)) = ((X1 * (X2 + X3)) + X4)))).
+step(add(rule(51, ((X1 * X2) + ((X3 * X2) + X4)) = (((X1 + X3) * X2) + X4)))).
+step(add(rule(52, ((X1 * (X2 * X4)) + (X3 * X4)) = (((X1 * X2) + X3) * X4)))).
+step(add(rule(53, (((X1 * X1) + X2) * X1) = (X1 + (X2 * X1))))).
+step(add(rule(54, (X1 + (-(X1 * X1) * X1)) = 0))).
+step(add(rule(55, (-(X1 * X1) * X1) = -X1))).
+step(add(rule(56, ((X1 + (X1 * X2)) * X3) = (X1 * (X3 + (X2 * X3)))))).
+step(add(rule(57, ((X2 + (X1 * X1)) * X1) = (X1 + (X2 * X1))))).
+step(add(rule(58, ((X1 * X4) + (X2 * (X3 * X4))) = ((X1 + (X2 * X3)) * X4)))).
+step(add(rule(59, (X1 * (X2 * (X1 * (X2 * (X1 * X2))))) = (X1 * X2)))).
+step(add(rule(60, (X1 * ((X1 * (X1 * X2)) + X3)) = (X1 * (X2 + X3))))).
+step(add(rule(61, (X1 * (X2 + (X1 * (X1 * X3)))) = (X1 * (X2 + X3))))).
+step(add(rule(62, (X1 * (X2 + X2)) = (X1 * (X1 * ((X1 + X1) * X2)))))).
+step(add(rule(63, (X1 * (X1 * (X1 + (X1 * X2)))) = (X1 + (X1 * X2))))).
+step(add(rule(64, (X1 + (X1 * (-(X1 * X1) + X2))) = (X1 * X2)))).
+step(add(rule(65, ((X1 + X1) * (X2 * X3)) = (X1 * (X2 * (X3 + X3)))))).
+step(add(rule(66, (-(X1 * X3) + (X1 * (X2 + X3))) = (X1 * X2)))).
+step(add(rule(67, -(X1 * -X2) = (X1 * X2)))).
+step(add(rule(68, -(X1 * X2) = (X1 * -X2)))).
+step(add(rule(69, (X1 * (X2 * (-X2 * -X2))) = (X1 * X2)))).
+step(add(rule(70, (-X1 * (X1 * -X1)) = X1))).
+step(add(rule(71, (X1 * (-X1 * -X1)) = X1))).
+step(add(rule(72, (-X1 * (X1 * X1)) = -X1))).
+step(add(rule(73, (X1 * (-X1 * X1)) = -X1))).
+step(add(rule(74, ((X2 * -X3) + ((X1 + X2) * X3)) = (X1 * X3)))).
+step(add(rule(75, (-X1 * -X2) = (X1 * X2)))).
+step(add(rule(76, (-X1 * X2) = (X1 * -X2)))).
+step(add(rule(77, (X2 + (X3 + (X1 + -(X2 + X3)))) = X1))).
+step(hard(X1 = (X2 + (X3 + (-(X3 + X2) + X1))))).
+step(add(rule(78, ((X1 + (X1 * X1)) * (X1 * X1)) = (X1 + (X1 * X1))))).
+step(add(rule(79, (X1 + (X1 * ((X1 + X1) * -X1))) = -X1))).
+step(add(rule(80, ((X1 * X2) + (X3 + (X1 * X4))) = (X3 + (X1 * (X4 + X2)))))).
+step(add(rule(81, ((X1 * X2) + (X3 + (X4 * X2))) = (X3 + ((X4 + X1) * X2))))).
+step(add(rule(82, ((X1 + X2) * (X3 + X3)) = ((X1 + (X2 + (X1 + X2))) * X3)))).
+step(add(rule(83, ((X1 + (X1 + X2)) * X3) = ((X1 * (X3 + X3)) + (X2 * X3))))).
+step(add(rule(84, ((X1 + (X1 + X1)) * X2) = (X1 * (X2 + (X2 + X2)))))).
+step(add(rule(85, ((X1 + (X2 + X2)) * X3) = ((X1 * X3) + (X2 * (X3 + X3)))))).
+step(hard(((X1 + X2) * (X3 + X3)) = ((X2 + (X1 + (X2 + X1))) * X3))).
+step(add(rule(86, ((X1 + X1) * (X2 + X3)) = (X1 * (X2 + (X3 + (X2 + X3))))))).
+step(add(rule(87, (X1 * (X2 + (X2 + X3))) = (((X1 + X1) * X2) + (X1 * X3))))).
+step(add(rule(88, (X1 * (X2 + (X3 + X3))) = ((X1 * X2) + ((X1 + X1) * X3))))).
+step(add(rule(89, (X1 + (X1 * (X2 + X2))) = (X1 + ((X1 + X1) * X2))))).
+step(add(rule(90, (X1 * -(X2 + X2)) = ((X1 + X1) * -X2)))).
+step(hard(((X1 + X1) * (X2 + X3)) = (X1 * (X3 + (X2 + (X3 + X2)))))).
+step(add(rule(91, (X1 * (((X1 * X1) + X2) * X3)) = ((X1 + (X1 * X2)) * X3)))).
+step(add(rule(92, (X1 * (X3 + ((X1 * X1) + X2))) = (X1 + (X1 * (X2 + X3)))))).
+step(add(rule(93, (X1 * (X2 + (X3 + (X1 * X1)))) = (X1 + (X1 * (X2 + X3)))))).
+step(add(rule(94, (X1 * ((X2 + (X1 * X1)) * X3)) = ((X1 + (X1 * X2)) * X3)))).
+step(add(rule(95, (X1 + (-(X2 + X1) + X3)) = (-X2 + X3)))).
+step(add(rule(96, (X3 + -(X1 + (X2 + X3))) = -(X1 + X2)))).
+step(add(rule(97, (X1 + (X2 + -(X3 + X1))) = (X2 + -X3)))).
+step(add(rule(98, (((X1 * X1) + X2) * (X1 * X3)) = ((X1 + (X2 * X1)) * X3)))).
+step(add(rule(99, ((X1 + (X2 * X3)) * (X3 * X3)) = (((X1 * X3) + X2) * X3)))).
+step(add(rule(100, ((X1 + (X2 * X2)) * (X2 * X3)) = ((X2 + (X1 * X2)) * X3)))).
+step(add(rule(101, (X1 * (X1 * -(X1 + X1))) = -(X1 + X1)))).
+step(add(rule(102, (X1 * (X1 * ((X1 + X1) * X2))) = ((X1 + X1) * X2)))).
+step(add(rule(103, ((X1 + (X1 + X1)) * (X1 * X1)) = (X1 + (X1 + X1))))).
+step(add(rule(104, ((X1 + (X1 * (X2 * X2))) * X2) = (X1 * (X2 + X2))))).
+step(add(rule(105, (((X1 * (X2 * X2)) + X3) * X2) = ((X1 + X3) * X2)))).
+step(add(rule(106, (X1 + (X1 * (X2 + (X1 * -X1)))) = (X1 * X2)))).
+step(add(rule(107, (X1 + (((X1 * -X1) + X2) * X1)) = (X2 * X1)))).
+step(add(rule(108, (X1 + ((X2 + (X1 * -X1)) * X1)) = (X2 * X1)))).
+step(add(rule(109, (X1 + ((-X2 + (X1 * X1)) * -X1)) = (X2 * X1)))).
+step(add(rule(110, ((X3 * -X2) + ((X3 + X1) * X2)) = (X1 * X2)))).
+step(hard(X1 = (X2 + (X3 + (X1 + -(X3 + X2)))))).
+step(add(rule(111, ((X3 * X2) + ((X1 + X3) * -X2)) = (X1 * -X2)))).
+step(add(rule(112, ((X1 + (X1 + (X1 + X1))) * X2) = (X1 * (X2 + (X2 + (X2 + X2))))))).
+step(add(rule(113, ((X1 * X3) + (X2 * (X1 * (X1 * X3)))) = ((X1 + X2) * (X1 * (X1 * X3)))))).
+step(add(rule(114, (X1 * ((X1 + X1) * ((X1 + X1) * (X2 + X2)))) = ((X1 + X1) * X2)))).
+step(add(rule(115, (((X1 + X2) * (X1 * X1)) + X3) = (X1 + ((X2 * (X1 * X1)) + X3))))).
+step(interreduce).
+step(delete(rule(11, (X1 + (-X1 + X2)) = X2))).
+step(delete(rule(13, (X1 + (X2 + X3)) = (X3 + (X1 + X2))))).
+step(delete(rule(17, (0 * (X1 + X1)) = (0 * X1)))).
+step(delete(rule(19, (X1 + (X2 + -(X1 + X2))) = 0))).
+step(delete(rule(20, (X1 + -(-X2 + X1)) = X2))).
+step(delete(rule(21, (X1 * ((X1 * X1) + X2)) = (X1 + (X1 * X2))))).
+step(delete(rule(22, (X1 + (X1 * 0)) = X1))).
+step(delete(rule(25, (X2 + -(X1 + X2)) = -X1))).
+step(delete(rule(26, ((X1 + X1) * (X1 * X1)) = (X1 + X1)))).
+step(delete(rule(27, (X2 + -(X2 + -X1)) = X1))).
+step(delete(rule(28, -(-X1 + -X2) = (X2 + X1)))).
+step(delete(rule(29, (X1 * (0 * X2)) = (0 * X2)))).
+step(delete(rule(36, (X1 + (X1 * -(X1 * X1))) = 0))).
+step(delete(rule(37, (-X1 * -(-X1 * -X1)) = X1))).
+step(delete(rule(38, (-X1 * (-X1 * X1)) = X1))).
+step(delete(rule(39, (X1 * -(X1 * X1)) = -X1))).
+step(delete(rule(45, (X1 + (0 * X1)) = X1))).
+step(delete(rule(47, (X2 + (X3 + (-(X2 + X3) + X1))) = X1))).
+step(delete(rule(50, ((X1 * X2) + ((X1 * X3) + X4)) = ((X1 * (X2 + X3)) + X4)))).
+step(delete(rule(51, ((X1 * X2) + ((X3 * X2) + X4)) = (((X1 + X3) * X2) + X4)))).
+step(delete(rule(53, (((X1 * X1) + X2) * X1) = (X1 + (X2 * X1))))).
+step(delete(rule(54, (X1 + (-(X1 * X1) * X1)) = 0))).
+step(delete(rule(55, (-(X1 * X1) * X1) = -X1))).
+step(delete(rule(60, (X1 * ((X1 * (X1 * X2)) + X3)) = (X1 * (X2 + X3))))).
+step(delete(rule(62, (X1 * (X2 + X2)) = (X1 * (X1 * ((X1 + X1) * X2)))))).
+step(delete(rule(64, (X1 + (X1 * (-(X1 * X1) + X2))) = (X1 * X2)))).
+step(delete(rule(66, (-(X1 * X3) + (X1 * (X2 + X3))) = (X1 * X2)))).
+step(delete(rule(67, -(X1 * -X2) = (X1 * X2)))).
+step(delete(rule(69, (X1 * (X2 * (-X2 * -X2))) = (X1 * X2)))).
+step(delete(rule(70, (-X1 * (X1 * -X1)) = X1))).
+step(delete(rule(71, (X1 * (-X1 * -X1)) = X1))).
+step(delete(rule(72, (-X1 * (X1 * X1)) = -X1))).
+step(delete(rule(73, (X1 * (-X1 * X1)) = -X1))).
+step(delete(rule(74, ((X2 * -X3) + ((X1 + X2) * X3)) = (X1 * X3)))).
+step(delete(rule(75, (-X1 * -X2) = (X1 * X2)))).
+step(delete(rule(77, (X2 + (X3 + (X1 + -(X2 + X3)))) = X1))).
+step(delete(rule(78, ((X1 + (X1 * X1)) * (X1 * X1)) = (X1 + (X1 * X1))))).
+step(delete(rule(79, (X1 + (X1 * ((X1 + X1) * -X1))) = -X1))).
+step(delete(rule(91, (X1 * (((X1 * X1) + X2) * X3)) = ((X1 + (X1 * X2)) * X3)))).
+step(delete(rule(95, (X1 + (-(X2 + X1) + X3)) = (-X2 + X3)))).
+step(delete(rule(98, (((X1 * X1) + X2) * (X1 * X3)) = ((X1 + (X2 * X1)) * X3)))).
+step(delete(rule(107, (X1 + (((X1 * -X1) + X2) * X1)) = (X2 * X1)))).
+step(add(rule(116, (X1 + (X2 * (X3 * (X1 * X1)))) = ((X1 + (X2 * X3)) * (X1 * X1))))).
+step(add(rule(117, (X1 + (X2 + (X3 * (X1 * X1)))) = (X2 + ((X1 + X3) * (X1 * X1)))))).
+step(add(rule(118, (X1 * (X1 * (X1 + (X1 + X1)))) = (X1 + (X1 + X1))))).
+step(add(rule(119, ((X1 + (X2 + X2)) * (X1 * X1)) = (X1 + (X2 * (X1 * (X1 + X1))))))).
+step(add(rule(120, (X1 + (X1 * (X2 * (X3 * X1)))) = (X1 * (((X2 * X3) + X1) * X1))))).
+step(add(rule(121, ((X2 * -X3) + (X1 * X3)) = ((X1 + -X2) * X3)))).
+step(add(rule(122, (X1 + (-(X1 + X2) + X3)) = (-X2 + X3)))).
+step(add(rule(123, (X1 + (X2 + -(X1 + X3))) = (X2 + -X3)))).
+step(add(rule(124, (X3 + -(X1 + (X3 + X2))) = -(X1 + X2)))).
+step(add(rule(125, (X1 * (X1 * (X2 + (X1 * X3)))) = (X1 * ((X1 * X2) + X3))))).
+step(add(rule(126, ((X3 + (X3 + (X2 + X2))) * X4) = ((X3 + X2) * (X4 + X4))))).
+step(hard(((X1 + X2) * (X3 + X3)) = ((X1 + (X2 + (X2 + X1))) * X3))).
+step(hard(((X1 + X2) * (X3 + X3)) = ((X2 + (X1 + (X1 + X2))) * X3))).
+step(hard(((X1 * (X2 + X2)) + (X3 * X2)) = ((X1 + (X3 + X1)) * X2))).
+step(add(rule(127, ((X1 + (X1 + X2)) * X3) = ((X2 * X3) + (X1 * (X3 + X3)))))).
+step(hard(((X1 + (X1 + X2)) * X3) = ((X2 + (X1 + X1)) * X3))).
+step(hard(((X1 * X2) + (X3 * (X2 + X2))) = ((X3 + (X1 + X3)) * X2))).
+step(hard(((X1 + (X2 + X2)) * X3) = ((X2 * (X3 + X3)) + (X1 * X3)))).
+step(add(rule(128, (X1 * (X4 + (X4 + (X3 + X3)))) = ((X1 + X1) * (X4 + X3))))).
+step(hard(((X1 + X1) * (X2 + X3)) = (X1 * (X2 + (X3 + (X3 + X2)))))).
+step(hard(((X1 + X1) * (X2 + X3)) = (X1 * (X3 + (X2 + (X2 + X3)))))).
+step(hard((((X1 + X1) * X2) + (X1 * X3)) = (X1 * (X2 + (X3 + X2))))).
+step(add(rule(129, (X1 * (X2 + (X2 + X3))) = ((X1 * X3) + ((X1 + X1) * X2))))).
+step(hard((X1 * (X2 + (X2 + X3))) = (X1 * (X3 + (X2 + X2))))).
+step(hard(((X1 * X2) + ((X1 + X1) * X3)) = (X1 * (X3 + (X2 + X3))))).
+step(hard((X1 * (X2 + (X3 + X3))) = (((X1 + X1) * X3) + (X1 * X2)))).
+step(add(rule(130, (X1 * ((X1 * (X1 * X2)) + (X3 + X3))) = ((X1 * X2) + ((X1 + X1) * X3))))).
+step(add(rule(131, (((X3 * X2) + X1) * (X2 * X2)) = (((X1 * X2) + X3) * X2)))).
+step(add(rule(132, (X2 + (-X2 + (X1 * -X2))) = (X1 * -X2)))).
+step(add(rule(133, (X1 * ((X1 + X1) * (X1 + (X1 + (X1 + X1))))) = (X1 + X1)))).
+step(add(rule(134, (X4 + (X2 + (X3 + (-X4 + X1)))) = (X1 + (X2 + X3))))).
+step(add(rule(135, -(X1 + (-X2 + X3)) = (X2 + -(X3 + X1))))).
+step(add(rule(136, (X4 + (X1 + (X2 + (X3 + -X4)))) = (X1 + (X2 + X3))))).
+step(add(rule(137, -(X1 + (X2 + -X3)) = (X3 + -(X1 + X2))))).
+step(add(rule(138, (-X1 + (-X2 + X3)) = (-(X2 + X1) + X3)))).
+step(add(rule(139, (-X1 + (X2 + -X3)) = (X2 + -(X3 + X1))))).
+step(add(rule(140, -(X3 + (X1 * -X2)) = ((X1 * X2) + -X3)))).
+step(add(rule(141, ((X2 * -X3) + -X1) = -(X1 + (X2 * X3))))).
+step(add(rule(142, (-X3 + (X1 * -X2)) = -((X1 * X2) + X3)))).
+step(add(rule(143, ((X1 + -X2) * -X3) = ((X2 + -X1) * X3)))).
+step(add(rule(144, ((X2 + (X1 * (X3 * X3))) * X3) = ((X1 + X2) * X3)))).
+step(add(rule(145, ((X1 + X1) * (X1 + (X1 + (X1 + X1)))) = (X1 * (X1 + X1))))).
+step(add(rule(146, (X1 + (X1 * ((X1 * -X1) + X2))) = (X1 * X2)))).
+step(add(rule(147, (X2 + (-X2 + (X1 * X2))) = (X1 * X2)))).
+step(add(rule(148, ((X1 * (X2 + X2)) + ((X1 + X1) * X3)) = ((X1 + X1) * (X2 + X3))))).
+step(add(rule(149, (((X1 + X1) * X2) + (X1 * (X3 + X3))) = ((X1 + X1) * (X2 + X3))))).
+step(add(rule(150, (X1 + (X1 + ((X1 + X1) * X2))) = ((X1 + X1) * (X2 + (X1 * X1)))))).
+step(add(rule(151, (((X1 + X1) * X3) + (X2 * (X3 + X3))) = ((X1 + X2) * (X3 + X3))))).
+step(add(rule(152, ((X1 * (X3 + X3)) + ((X2 + X2) * X3)) = ((X1 + X2) * (X3 + X3))))).
+step(add(rule(153, (((X1 + X1) * -X2) + X3) = ((X1 * -(X2 + X2)) + X3)))).
+step(add(rule(154, ((X1 * (X2 + X2)) + X3) = (((X1 + X1) * X2) + X3)))).
+step(add(rule(155, (X1 + ((X2 + X2) * X3)) = (X1 + (X2 * (X3 + X3)))))).
+step(add(rule(156, (X1 + ((X1 + (X1 * X1)) * -X1)) = (X1 * -X1)))).
+step(add(rule(157, (X2 + ((X1 + (X2 * X2)) * -X2)) = (X1 * -X2)))).
+step(add(rule(158, ((((X2 * -X2) + X1) * -X2) + X3) = (X2 + (X3 + (X1 * -X2)))))).
+step(add(rule(159, ((X3 * X2) + ((X3 + X1) * -X2)) = (X1 * -X2)))).
+step(add(rule(160, (((? * X2) + ((? * X2) + ((X3 + ?) * -(X2 + X2)))) * X4) = (X3 * (X2 * -(X4 + X4)))))).
+step(add(rule(161, (((X1 * X2) + ((X1 * X2) + ((X3 + X1) * -(X2 + X2)))) * X4) = (((? * X2) + ((? * X2) + ((X3 + ?) * -(X2 + X2)))) * X4)))).
+step(interreduce).
+step(delete(rule(63, (X1 * (X1 * (X1 + (X1 * X2)))) = (X1 + (X1 * X2))))).
+step(delete(rule(82, ((X1 + X2) * (X3 + X3)) = ((X1 + (X2 + (X1 + X2))) * X3)))).
+step(delete(rule(85, ((X1 + (X2 + X2)) * X3) = ((X1 * X3) + (X2 * (X3 + X3)))))).
+step(delete(rule(86, ((X1 + X1) * (X2 + X3)) = (X1 * (X2 + (X3 + (X2 + X3))))))).
+step(delete(rule(88, (X1 * (X2 + (X3 + X3))) = ((X1 * X2) + ((X1 + X1) * X3))))).
+step(delete(rule(89, (X1 + (X1 * (X2 + X2))) = (X1 + ((X1 + X1) * X2))))).
+step(delete(rule(96, (X3 + -(X1 + (X2 + X3))) = -(X1 + X2)))).
+step(delete(rule(104, ((X1 + (X1 * (X2 * X2))) * X2) = (X1 * (X2 + X2))))).
+step(delete(rule(105, (((X1 * (X2 * X2)) + X3) * X2) = ((X1 + X3) * X2)))).
+step(delete(rule(109, (X1 + ((-X2 + (X1 * X1)) * -X1)) = (X2 * X1)))).
+step(delete(rule(110, ((X3 * -X2) + ((X3 + X1) * X2)) = (X1 * X2)))).
+step(delete(rule(111, ((X3 * X2) + ((X1 + X3) * -X2)) = (X1 * -X2)))).
+step(delete(rule(122, (X1 + (-(X1 + X2) + X3)) = (-X2 + X3)))).
+step(delete(rule(132, (X2 + (-X2 + (X1 * -X2))) = (X1 * -X2)))).
+step(delete(rule(133, (X1 * ((X1 + X1) * (X1 + (X1 + (X1 + X1))))) = (X1 + X1)))).
+step(delete(rule(134, (X4 + (X2 + (X3 + (-X4 + X1)))) = (X1 + (X2 + X3))))).
+step(delete(rule(135, -(X1 + (-X2 + X3)) = (X2 + -(X3 + X1))))).
+step(delete(rule(138, (-X1 + (-X2 + X3)) = (-(X2 + X1) + X3)))).
+step(delete(rule(156, (X1 + ((X1 + (X1 * X1)) * -X1)) = (X1 * -X1)))).
+step(delete(rule(160, (((? * X2) + ((? * X2) + ((X3 + ?) * -(X2 + X2)))) * X4) = (X3 * (X2 * -(X4 + X4)))))).
+step(add(rule(162, (((? * X2) + ((? * X2) + ((? + X3) * -(X2 + X2)))) * X4) = (X3 * (X2 * -(X4 + X4)))))).
+step(delete(rule(161, (((X1 * X2) + ((X1 * X2) + ((X3 + X1) * -(X2 + X2)))) * X4) = (((? * X2) + ((? * X2) + ((X3 + ?) * -(X2 + X2)))) * X4)))).
+step(add(rule(163, (((X1 * X2) + ((X1 * X2) + ((X3 + X1) * -(X2 + X2)))) * X4) = (((? * X2) + ((? * X2) + ((? + X3) * -(X2 + X2)))) * X4)))).
+step(add(rule(164, (X1 * (X2 * ((X3 + X3) * X4))) = ((X1 + X1) * (X2 * (X3 * X4)))))).
+step(add(rule(165, (X1 * (X2 * ((X3 + X3) * X4))) = (X1 * ((X2 + X2) * (X3 * X4)))))).
+step(add(rule(166, ((X1 + X1) * (X2 * ((X2 + X2) * (X2 + X2)))) = (X1 * (X2 + X2))))).
+step(add(rule(167, (X1 * (X2 * (X3 * (X4 + X4)))) = (X1 * (X2 * ((X3 + X3) * X4)))))).
+step(add(rule(168, (X1 * (((X2 + X2) * X3) + X4)) = (X1 * ((X2 * (X3 + X3)) + X4))))).
+step(add(rule(169, (X1 * (X2 + ((X3 + X3) * X4))) = (X1 * (X2 + (X3 * (X4 + X4))))))).
+step(add(rule(170, ((X1 * (X1 * (X1 + X2))) + X3) = (X1 + ((X1 * (X1 * X2)) + X3))))).
+step(add(rule(171, (X1 + (X2 + (X1 * (X1 * X3)))) = (X2 + (X1 * (X1 * (X1 + X3))))))).
+step(add(rule(172, (X1 * (X1 * (X1 + (X2 + X2)))) = (X1 + (X1 * ((X1 + X1) * X2)))))).
+step(add(rule(173, ((X1 * ((X1 + X2) * X1)) + X3) = (X1 + ((X1 * (X2 * X1)) + X3))))).
+step(add(rule(174, (X1 + (X2 + (X1 * (X3 * X1)))) = (X2 + (X1 * ((X1 + X3) * X1)))))).
+step(add(rule(175, (X1 * ((X1 + (X2 + X2)) * X1)) = (X1 + (X1 * (X2 * (X1 + X1))))))).
+step(add(rule(176, ((((X1 + X1) * X2) + X3) * X4) = (((X1 * (X2 + X2)) + X3) * X4)))).
+step(add(rule(177, ((X1 + (X1 * X2)) * (X3 * X4)) = (X1 * ((X3 + (X2 * X3)) * X4))))).
+step(add(rule(178, (X1 * (X2 * (X3 + (X4 * X3)))) = (X1 * ((X2 + (X2 * X4)) * X3))))).
+step(add(rule(179, (X1 * (X2 + ((X3 + X3) * X2))) = ((X1 + ((X1 + X1) * X3)) * X2)))).
+step(add(rule(180, (X1 * (X2 + (X1 * (X3 * X2)))) = (X1 * (X1 * ((X1 + X3) * X2)))))).
+step(add(rule(181, (X1 * (X2 + (X3 * (X1 * X2)))) = (X1 * ((X1 + X3) * (X1 * X2)))))).
+step(add(rule(182, ((X1 + (X1 * (X2 * X3))) * X4) = (X1 * (X4 + (X2 * (X3 * X4))))))).
+step(add(rule(183, ((X1 + (X1 * (X2 + X2))) * X3) = (X1 * (X3 + (X2 * (X3 + X3))))))).
+step(add(rule(184, ((X1 + ((X2 + X2) * X3)) * X4) = ((X1 + (X2 * (X3 + X3))) * X4)))).
+step(add(rule(185, (X1 * -(X2 + (X1 * X1))) = -(X1 + (X1 * X2))))).
+step(add(rule(186, ((X1 + (X2 * X2)) * -X2) = -(X2 + (X1 * X2))))).
+step(add(rule(187, ((X2 * X1) + -(X1 + (X2 * X1))) = -X1))).
+step(add(rule(188, ((X1 * X3) + (X2 * -X3)) = ((X1 + -X2) * X3)))).
+step(add(rule(189, ((X1 * X2) + (X3 * (X2 + X4))) = ((X3 * X4) + ((X1 + X3) * X2))))).
+step(hard(((X1 + (X3 + X1)) * X2) = ((X3 + (X1 + X1)) * X2))).
+step(hard(((X1 + (X3 + X1)) * X2) = ((X1 + (X1 + X3)) * X2))).
+step(add(rule(190, (X1 + (X1 * ((X1 * X2) + X3))) = (X1 * (X3 + (X1 * (X1 + X2))))))).
+step(add(rule(191, (X1 + (X1 * ((X2 * X1) + X3))) = (X1 * (X3 + ((X1 + X2) * X1)))))).
+step(hard(((X1 + (X1 + X2)) * (X2 * X2)) = (X2 + (X1 * (X2 * (X2 + X2)))))).
+step(hard((X1 + (X1 * (X2 * (X1 + X1)))) = (X1 * ((X2 + (X2 + X1)) * X1)))).
+step(hard((X1 + (X1 * ((X1 + X1) * X2))) = (X1 * (X1 * (X2 + (X2 + X1)))))).
+step(add(rule(192, (X1 * ((X2 * X3) + ((X2 * X3) + X4))) = (X1 * (((X2 + X2) * X3) + X4))))).
+step(add(rule(193, (X1 * (X2 + (X2 + (X3 * X2)))) = ((X1 + (X1 + (X1 * X3))) * X2)))).
+step(add(rule(194, (X1 + (X1 + (X1 * (X2 + X2)))) = ((X1 + X1) * ((X1 * X1) + X2))))).
+step(add(rule(195, (X1 + (X1 * (X2 + (X1 * X3)))) = (X1 * (X2 + (X1 * (X3 + X1))))))).
+step(add(rule(196, (X1 + (X1 * (X2 + (X3 * X1)))) = (X1 * (X2 + ((X3 + X1) * X1)))))).
+step(add(rule(197, ((X1 + (X2 + (X1 * X1))) * (X1 * X1)) = (X1 + ((X1 + (X2 * X1)) * X1))))).
+step(add(rule(198, ((X1 + (X2 * -X2)) * -X2) = (X2 + (X1 * -X2))))).
+step(add(rule(199, (((X2 + X1) * (X1 * X1)) + X3) = (X1 + ((X2 * (X1 * X1)) + X3))))).
+step(add(rule(200, (X1 + (((X2 * X1) + X3) * X1)) = ((((X1 + X2) * X1) + X3) * X1)))).
+step(add(rule(201, (X1 + ((X2 + X3) * (X2 * X2))) = (X2 + ((X3 * (X2 * X2)) + X1))))).
+step(add(rule(202, ((X1 + ((X1 * X1) + X2)) * (X1 * X1)) = ((X1 + ((X2 + X1) * X1)) * X1)))).
+step(add(rule(203, (X1 + (X2 + (X3 * (X1 * X1)))) = (X2 + ((X3 + X1) * (X1 * X1)))))).
+step(add(rule(204, (X1 + ((X2 + (X3 * X1)) * X1)) = ((X2 + ((X1 + X3) * X1)) * X1)))).
+step(hard((X1 + (X2 * (X1 * (X1 + X1)))) = ((X2 + (X1 + X2)) * (X1 * X1)))).
+step(add(rule(205, ((X1 + X1) * (X2 + (X2 + X2))) = ((X1 + (X1 + X1)) * (X2 + X2))))).
+step(add(rule(206, (X1 * (X2 + (X2 + (X1 * (X1 + X1))))) = ((X1 + X1) * (X2 + (X1 * X1)))))).
+step(simplify_queue).
+step(interreduce).
+step(delete(rule(106, (X1 + (X1 * (X2 + (X1 * -X1)))) = (X1 * X2)))).
+step(delete(rule(117, (X1 + (X2 + (X3 * (X1 * X1)))) = (X2 + ((X1 + X3) * (X1 * X1)))))).
+step(delete(rule(121, ((X2 * -X3) + (X1 * X3)) = ((X1 + -X2) * X3)))).
+step(delete(rule(146, (X1 + (X1 * ((X1 * -X1) + X2))) = (X1 * X2)))).
+step(delete(rule(157, (X2 + ((X1 + (X2 * X2)) * -X2)) = (X1 * -X2)))).
+step(delete(rule(158, ((((X2 * -X2) + X1) * -X2) + X3) = (X2 + (X3 + (X1 * -X2)))))).
+step(delete(rule(159, ((X3 * X2) + ((X3 + X1) * -X2)) = (X1 * -X2)))).
+step(delete(rule(190, (X1 + (X1 * ((X1 * X2) + X3))) = (X1 * (X3 + (X1 * (X1 + X2))))))).
+step(delete(rule(191, (X1 + (X1 * ((X2 * X1) + X3))) = (X1 * (X3 + ((X1 + X2) * X1)))))).
+step(delete(rule(197, ((X1 + (X2 + (X1 * X1))) * (X1 * X1)) = (X1 + ((X1 + (X2 * X1)) * X1))))).
+step(add(rule(207, ((X1 + (X2 + (X1 * X1))) * (X1 * X1)) = ((X1 + ((X1 + X2) * X1)) * X1)))).
+step(delete(rule(200, (X1 + (((X2 * X1) + X3) * X1)) = ((((X1 + X2) * X1) + X3) * X1)))).
+step(delete(rule(202, ((X1 + ((X1 * X1) + X2)) * (X1 * X1)) = ((X1 + ((X2 + X1) * X1)) * X1)))).
+step(hard(((X1 + X3) * (X2 + X2)) = ((X3 + X1) * (X2 + X2)))).
+step(hard(((X1 + X1) * (X2 + X3)) = ((X1 + X1) * (X3 + X2)))).
+step(add(rule(208, (X2 + (X2 + (X1 * (X2 * (X2 + X2))))) = ((X1 + X2) * (X2 * (X2 + X2)))))).
+step(add(rule(209, (X1 * ((X1 + X1) * (X1 + X1))) = (X1 + (X1 + (X1 + X1)))))).
+step(add(rule(210, (X3 + (X4 + (X2 + (-(X3 + X4) + X1)))) = (X1 + X2)))).
+step(add(rule(211, (X3 + (X4 + (X1 + (X2 + -(X3 + X4))))) = (X1 + X2)))).
+step(add(rule(212, (X1 * ((X1 * (X1 + X1)) + X2)) = (X1 + (X1 + (X1 * X2)))))).
+step(add(rule(213, (X1 * (X2 + (X1 * (X1 + X1)))) = (X1 + (X1 + (X1 * X2)))))).
+step(add(rule(214, ((X2 + (X3 + (X1 * X1))) * X1) = (X1 + ((X2 + X3) * X1))))).
+step(add(rule(215, (X2 + (X2 + (X1 * (X2 + X2)))) = ((X1 + (X2 * X2)) * (X2 + X2))))).
+step(add(rule(216, ((X1 + X1) * (X2 + X2)) = (X1 * ((X1 + X1) * ((X1 + X1) * X2)))))).
+step(add(rule(217, ((X1 + X1) * ((X1 + X1) * (X2 + X2))) = (X1 * ((X1 + X1) * X2))))).
+step(add(rule(218, (X1 * (X1 * ((X1 * X3) + X2))) = (X1 * ((X1 * X2) + X3))))).
+step(hard(((X1 + X2) * (X3 + X3)) = ((X1 + (X2 + (X1 + X2))) * X3))).
+step(hard(((X1 + (X1 + (X2 + X2))) * X3) = ((X2 + X1) * (X3 + X3)))).
+step(hard(((X1 + X1) * (X2 + X3)) = (X1 * (X2 + (X3 + (X2 + X3)))))).
+step(hard((X1 * (X2 + (X2 + (X3 + X3)))) = ((X1 + X1) * (X3 + X2)))).
+step(add(rule(219, ((X1 + (X2 * (X2 + X2))) * X2) = (X2 + (X2 + (X1 * X2)))))).
+step(add(rule(220, -(X2 + (-X1 + X3)) = (X1 + -(X2 + X3))))).
+step(add(rule(221, -((X1 * -X2) + X3) = ((X1 * X2) + -X3)))).
+step(add(rule(222, ((? + (-? + X2)) * (X3 + X3)) = ((X2 + X2) * X3)))).
+step(add(rule(223, ((X1 + (-X1 + X2)) * (X3 + X3)) = ((? + (-? + X2)) * (X3 + X3))))).
+step(add(rule(224, ((X1 + X1) * (? + (-? + X3))) = (X1 * (X3 + X3))))).
+step(add(rule(225, ((X1 + X1) * (X2 + (-X2 + X3))) = ((X1 + X1) * (? + (-? + X3)))))).
+step(add(rule(226, ((-X1 + X2) * -X3) = ((X1 + -X2) * X3)))).
+step(add(rule(227, ((X1 * X2) + -(X3 + (X1 * X2))) = -X3))).
+step(add(rule(228, (((X1 + X1) * X2) + X3) = (X3 + (X1 * (X2 + X2)))))).
+step(add(rule(229, ((X1 * (X2 + X2)) + X3) = (X3 + ((X1 + X1) * X2))))).
+step(add(rule(230, (X1 * (X2 * (X1 * (X2 * (X1 * (X2 * X3)))))) = (X1 * (X2 * X3))))).
+step(add(rule(231, ((X1 * (X2 * X3)) + ((X4 * X3) + X5)) = ((((X1 * X2) + X4) * X3) + X5)))).
+step(add(rule(232, ((X1 * (X2 * (X3 * X5))) + (X4 * X5)) = (((X1 * (X2 * X3)) + X4) * X5)))).
+step(add(rule(233, ((X1 * (X2 * X5)) + (X3 * (X4 * X5))) = (((X1 * X2) + (X3 * X4)) * X5)))).
+step(add(rule(234, ((X1 * (X2 * X3)) + (X4 + (X5 * X3))) = (X4 + (((X1 * X2) + X5) * X3))))).
+step(add(rule(235, ((((X1 + X1) * X2) + X3) * X4) = ((X1 * (X2 * (X4 + X4))) + (X3 * X4))))).
+step(add(rule(236, ((X1 + ((X1 + X1) * X2)) * X3) = (X1 * (X3 + (X2 * (X3 + X3))))))).
+step(add(rule(237, (((X1 * (X2 + X2)) + X3) * X4) = ((X1 * (X2 * (X4 + X4))) + (X3 * X4))))).
+step(add(rule(238, (((X1 * X2) + (X3 + X3)) * X4) = ((X1 * (X2 * X4)) + (X3 * (X4 + X4)))))).
+step(add(rule(239, (((X1 * X1) + (X2 + X2)) * X1) = (X1 + (X2 * (X1 + X1)))))).
+step(add(rule(240, ((X1 + X1) * ((X2 + (X1 * X1)) * X3)) = ((X1 + X1) * (X3 + (X2 * X3)))))).
+step(add(rule(241, ((X2 + ((X1 * X1) + X2)) * X1) = (X1 + (X2 * (X1 + X1)))))).
+step(add(rule(242, (((X1 * X2) + X3) * (X2 * (X2 * X4))) = ((X1 + (X3 * X2)) * (X2 * X4))))).
+step(add(rule(243, ((X1 + (X1 * (X2 * -X2))) * (X2 * X3)) = 0))).
+step(add(rule(244, (X1 * (X2 + (X2 * (X1 * -X1)))) = 0))).
+step(add(rule(245, ((X1 + (X1 * (X2 * -X2))) * (X2 + X2)) = 0))).
+step(add(rule(246, (X1 * ((X2 + (X2 * (X1 * -X1))) * X3)) = 0))).
+step(add(rule(247, ((X1 + (X1 * (X2 * -X2))) * -X2) = 0))).
+step(add(rule(248, (X1 * -(X2 + (X2 * (X1 * -X1)))) = 0))).
+step(add(rule(249, (X1 * (-X2 + (X2 * (X1 * X1)))) = 0))).
+step(add(rule(250, ((X1 * X2) + ((X3 * (X4 * X2)) + X5)) = (((X1 + (X3 * X4)) * X2) + X5)))).
+step(add(rule(251, ((X1 * X5) + (X2 * (X3 * (X4 * X5)))) = ((X1 + (X2 * (X3 * X4))) * X5)))).
+step(add(rule(252, ((X1 * X2) + (X3 + (X4 * (X5 * X2)))) = (X3 + ((X1 + (X4 * X5)) * X2))))).
+step(add(rule(253, (X1 + ((X2 + (X1 * X3)) * X1)) = ((X2 + (X1 * (X1 + X3))) * X1)))).
+step(add(rule(254, ((X1 + (X1 + (X2 * X3))) * X4) = ((X1 * (X4 + X4)) + (X2 * (X3 * X4)))))).
+step(add(rule(255, ((X1 + ((X2 + X2) * X3)) * X4) = ((X1 * X4) + (X2 * (X3 * (X4 + X4))))))).
+step(add(rule(256, ((X1 + (X2 * (X3 + X3))) * X4) = ((X1 * X4) + (X2 * (X3 * (X4 + X4))))))).
+step(add(rule(257, ((X1 + (X2 * X3)) * (X3 * (X3 * X4))) = (((X1 * X3) + X2) * (X3 * X4))))).
+step(add(rule(258, (X1 * ((X2 * (X1 * (X2 * (X1 * X2)))) + X3)) = (X1 * (X2 + X3))))).
+step(add(rule(259, (X1 * (X2 + (X3 * (X1 * (X3 * (X1 * X3)))))) = (X1 * (X2 + X3))))).
+step(add(rule(260, (X2 + ((X1 + X2) * (X2 * -X2))) = (X1 * (X2 * -X2))))).
+step(add(rule(261, (X1 * (X2 * -(X3 + X3))) = (X1 * ((X2 + X2) * -X3))))).
+step(add(rule(262, (X1 * (X2 + (X3 * X2))) = (X1 * (X1 * ((X1 + (X1 * X3)) * X2)))))).
+step(add(rule(263, (X1 * (X2 + (X3 + (X1 * (X1 * X4))))) = (X1 * (X2 + (X3 + X4)))))).
+step(add(rule(264, (X1 * ((X2 + (X1 * (X1 * X3))) * X4)) = (X1 * ((X2 + X3) * X4))))).
+step(add(rule(265, (X1 * (X2 + (X3 + X3))) = (X1 * (X2 + (X1 * ((X1 + X1) * X3))))))).
+step(add(rule(266, (X1 * (X2 + (X1 * (X1 + (X1 * X3))))) = (X1 + (X1 * (X2 + X3)))))).
+step(add(rule(267, (X1 * (X2 * -(X3 + X3))) = ((X1 + X1) * (X2 * -X3))))).
+step(add(rule(268, ((X1 + (X1 * X2)) * -X3) = (X1 * -(X3 + (X2 * X3)))))).
+step(add(rule(269, (X1 + (X2 * (X1 * -X1))) = ((X1 + -X2) * (X1 * X1))))).
+step(add(rule(270, ((X1 + X1) * (X1 + X1)) = (X1 * -(X1 + X1))))).
+step(add(rule(271, ((X1 + X1) * -(X1 + X1)) = (X1 * (X1 + X1))))).
+step(add(rule(272, (X1 + (X1 + (X1 + X1))) = -(X1 + X1)))).
+step(add(rule(273, -(X1 + (X1 + X1)) = (X1 + (X1 + X1))))).
+step(add(rule(274, (-X1 + (X2 * (X1 * X1))) = ((-X1 + X2) * (X1 * X1))))).
+step(add(rule(275, -(X1 + (X1 * (X2 * -X1))) = (X1 * ((X2 + -X1) * X1))))).
+step(add(rule(276, (X1 + (X1 * (X2 * -X1))) = (X1 * ((X1 + -X2) * X1))))).
+step(add(rule(277, ((X1 + (X1 * -X2)) * X3) = (X1 * (X3 + (X2 * -X3)))))).
+step(add(rule(278, (X1 * (X2 + (X2 + X2))) = ((X1 + (X1 + X1)) * -X2)))).
+step(add(rule(279, ((X1 + X1) * (X2 + (X2 + X2))) = 0))).
+step(interreduce).
+step(delete(rule(108, (X1 + ((X2 + (X1 * -X1)) * X1)) = (X2 * X1)))).
+step(delete(rule(112, ((X1 + (X1 + (X1 + X1))) * X2) = (X1 * (X2 + (X2 + (X2 + X2))))))).
+step(delete(rule(113, ((X1 * X3) + (X2 * (X1 * (X1 * X3)))) = ((X1 + X2) * (X1 * (X1 * X3)))))).
+step(delete(rule(114, (X1 * ((X1 + X1) * ((X1 + X1) * (X2 + X2)))) = ((X1 + X1) * X2)))).
+step(delete(rule(145, ((X1 + X1) * (X1 + (X1 + (X1 + X1)))) = (X1 * (X1 + X1))))).
+step(delete(rule(154, ((X1 * (X2 + X2)) + X3) = (((X1 + X1) * X2) + X3)))).
+step(delete(rule(166, ((X1 + X1) * (X2 * ((X2 + X2) * (X2 + X2)))) = (X1 * (X2 + X2))))).
+step(add(rule(280, ((X1 + X1) * -(X2 + X2)) = (X1 * (X2 + X2))))).
+step(delete(rule(187, ((X2 * X1) + -(X1 + (X2 * X1))) = -X1))).
+step(delete(rule(205, ((X1 + X1) * (X2 + (X2 + X2))) = ((X1 + (X1 + X1)) * (X2 + X2))))).
+step(add(rule(281, ((X1 + (X1 + X1)) * (X2 + X2)) = 0))).
+step(delete(rule(209, (X1 * ((X1 + X1) * (X1 + X1))) = (X1 + (X1 + (X1 + X1)))))).
+step(delete(rule(210, (X3 + (X4 + (X2 + (-(X3 + X4) + X1)))) = (X1 + X2)))).
+step(delete(rule(212, (X1 * ((X1 * (X1 + X1)) + X2)) = (X1 + (X1 + (X1 * X2)))))).
+step(delete(rule(231, ((X1 * (X2 * X3)) + ((X4 * X3) + X5)) = ((((X1 * X2) + X4) * X3) + X5)))).
+step(delete(rule(242, (((X1 * X2) + X3) * (X2 * (X2 * X4))) = ((X1 + (X3 * X2)) * (X2 * X4))))).
+step(delete(rule(247, ((X1 + (X1 * (X2 * -X2))) * -X2) = 0))).
+step(delete(rule(250, ((X1 * X2) + ((X3 * (X4 * X2)) + X5)) = (((X1 + (X3 * X4)) * X2) + X5)))).
+step(delete(rule(258, (X1 * ((X2 * (X1 * (X2 * (X1 * X2)))) + X3)) = (X1 * (X2 + X3))))).
+step(delete(rule(260, (X2 + ((X1 + X2) * (X2 * -X2))) = (X1 * (X2 * -X2))))).
+step(delete(rule(271, ((X1 + X1) * -(X1 + X1)) = (X1 * (X1 + X1))))).
+step(delete(rule(275, -(X1 + (X1 * (X2 * -X1))) = (X1 * ((X2 + -X1) * X1))))).
+step(add(rule(282, ((X1 + (X1 + X1)) * -(X2 + X2)) = 0))).
+step(add(rule(283, ((X1 + X1) * (X2 + X2)) = (X1 * -(X2 + X2))))).
+step(add(rule(284, ((X1 + (X1 + X1)) * ((X2 + X2) * X3)) = 0))).
+step(add(rule(285, ((X1 + (X1 + X1)) * (X2 * (X3 + X3))) = 0))).
+step(add(rule(286, ((X1 + X1) * ((X2 + (X2 + X2)) * X3)) = 0))).
+step(add(rule(287, (((X1 + X1) * X2) + (((X1 + X1) * X2) + (((X1 + X1) * X2) + X3))) = X3))).
+step(add(rule(288, (((X1 + (X1 + X1)) * X2) + (((X1 + (X1 + X1)) * X2) + X3)) = X3))).
+step(add(rule(289, ((X1 + X1) * (X2 + (X2 * (X1 * (X1 + X1))))) = 0))).
+step(add(rule(290, ((X1 + (X1 * (X2 * (X2 + X2)))) * (X2 + X2)) = 0))).
+step(add(rule(291, ((X1 + X1) * (X2 * (X3 + (X3 + X3)))) = 0))).
+step(add(rule(292, (X1 * (X2 + (X2 + X3))) = (X1 * ((X1 * ((X1 + X1) * X2)) + X3))))).
+step(add(rule(293, ((X1 + (X1 + X1)) * (X1 * ((X1 + X1) * X2))) = 0))).
+step(add(rule(294, ((X1 + (X1 + X1)) * (X1 * -(X1 + X1))) = 0))).
+step(add(rule(295, (X1 * (-X2 + (-X2 + X3))) = (X1 * (-(X2 + X2) + X3))))).
+step(add(rule(296, (X1 * (X1 * ((X1 + (X1 * X2)) * X3))) = ((X1 + (X1 * X2)) * X3)))).
+step(add(rule(297, (((X1 * (X2 * (X3 * X3))) + X4) * X3) = (((X1 * X2) + X4) * X3)))).
+step(add(rule(298, (((X1 * (X2 * (X2 + X2))) + X3) * X2) = ((X1 + (X1 + X3)) * X2)))).
+step(add(rule(299, (X1 * (-(X2 + X2) + X3)) = (X1 * (X3 + -(X2 + X2)))))).
+step(add(rule(300, ((X1 * -(X2 + X2)) + X3) = (X3 + ((X1 + X1) * -X2))))).
+step(add(rule(301, (X1 + ((X2 + X2) * -X3)) = (X1 + (X2 * -(X3 + X3)))))).
+step(add(rule(302, -(X3 + ((X1 + X1) * X2)) = -(X3 + (X1 * (X2 + X2)))))).
+step(add(rule(303, (((X1 + X1) * -X2) + X3) = (X3 + (X1 * -(X2 + X2)))))).
+step(add(rule(304, (((X1 * (X2 * X2)) + X3) * (X2 * X4)) = ((X1 + X3) * (X2 * X4))))).
+step(add(rule(305, ((X1 + (X2 * (X3 * X3))) * (X3 * X4)) = ((X1 + X2) * (X3 * X4))))).
+step(add(rule(306, (X1 * ((X1 * -X1) + X2)) = (-X1 + (X1 * X2))))).
+step(add(rule(307, (X1 + (-X1 + (X1 * X2))) = (X1 * X2)))).
+step(add(rule(308, (X1 * (X2 + (X1 * -X1))) = (-X1 + (X1 * X2))))).
+step(add(rule(309, (X1 * (X2 * (X3 * (X4 + X4)))) = ((X1 + X1) * (X2 * (X3 * X4)))))).
+step(add(rule(310, (X1 * (X2 * (X3 * (X4 + X4)))) = (X1 * ((X2 + X2) * (X3 * X4)))))).
+step(add(rule(311, ((X1 + X1) * (X2 * (X3 + X3))) = (X1 * (X2 * -(X3 + X3)))))).
+step(add(rule(312, ((X1 + X1) * ((X2 + X2) * X3)) = (X1 * (X2 * -(X3 + X3)))))).
+step(add(rule(313, ((X1 * (X2 + X2)) + ((X3 + -X1) * X2)) = ((X1 + X3) * X2)))).
+step(add(rule(314, ((X1 * (X2 + X2)) + ((-X1 + X3) * X2)) = ((X3 + X1) * X2)))).
+step(add(rule(315, ((X1 + (X1 + X1)) * (X2 * X3)) = (X1 * ((X2 + (X2 + X2)) * X3))))).
+step(add(rule(316, (X1 * (X2 * (X3 + (X3 + X3)))) = (X1 * ((X2 + (X2 + X2)) * X3))))).
+step(add(rule(317, (((X1 + X1) * X2) + (X1 * (X3 + -X2))) = (X1 * (X2 + X3))))).
+step(add(rule(318, (((X1 + X1) * X2) + (X1 * (-X2 + X3))) = (X1 * (X3 + X2))))).
+step(add(rule(319, (X1 * (X2 + (X2 * (X1 * X1)))) = ((X1 + X1) * X2)))).
+step(add(rule(320, (X1 + (X1 * (X2 + ((X1 * -X1) + X3)))) = (X1 * (X3 + X2))))).
+step(hard(((X1 + (X1 + (X2 + X2))) * X3) = ((X1 + (X2 + (X1 + X2))) * X3))).
+step(hard((X1 * (X2 + (X2 + (X3 + X3)))) = (X1 * (X2 + (X3 + (X2 + X3)))))).
+step(add(rule(321, (X1 * (((X2 + X2) * X3) + X4)) = (X1 * (X4 + ((X2 + X2) * X3)))))).
+step(add(rule(322, (X1 * (((X2 + X2) * X3) + X4)) = (X1 * (X4 + (X2 * (X3 + X3))))))).
+step(add(rule(323, (X1 * ((X2 * (X3 + X3)) + X4)) = (X1 * (X4 + ((X2 + X2) * X3)))))).
+step(add(rule(324, (X1 + (X1 * (X2 * (X3 + X3)))) = (X1 + (X1 * ((X2 + X2) * X3)))))).
+step(hard((X1 * (X2 * (X3 + (X4 + X4)))) = (X1 * (X2 * (X4 + (X4 + X3)))))).
+step(hard((X1 * ((X2 + (X4 + X4)) * X3)) = (X1 * ((X4 + (X4 + X2)) * X3)))).
+step(add(rule(325, ((X1 * (X1 * (X2 + X1))) + X3) = (X1 + ((X1 * (X1 * X2)) + X3))))).
+step(add(rule(326, (X1 + (X2 * (X2 * (X2 + X3)))) = (X2 + ((X2 * (X2 * X3)) + X1))))).
+step(add(rule(327, (X1 + (X2 + (X1 * (X1 * X3)))) = (X2 + (X1 * (X1 * (X3 + X1))))))).
+step(hard((X1 + (X1 * ((X1 + X1) * X2))) = (X1 * (X1 * (X2 + (X1 + X2)))))).
+step(add(rule(328, ((X1 * ((X2 + X1) * X1)) + X3) = (X1 + ((X1 * (X2 * X1)) + X3))))).
+step(add(rule(329, (X1 + (X2 * ((X2 + X3) * X2))) = (X2 + ((X2 * (X3 * X2)) + X1))))).
+step(add(rule(330, (X1 + (X2 + (X1 * (X3 * X1)))) = (X2 + (X1 * ((X3 + X1) * X1)))))).
+step(hard((X1 + (X1 * (X2 * (X1 + X1)))) = (X1 * ((X2 + (X1 + X2)) * X1)))).
+step(add(rule(331, (((X1 * (X2 + X2)) + X3) * X4) = ((X3 + ((X1 + X1) * X2)) * X4)))).
+step(add(rule(332, ((((X1 + X1) * X2) + X3) * X4) = ((X3 + (X1 * (X2 + X2))) * X4)))).
+step(add(rule(333, ((X1 + (X1 * X2)) * (X2 * X3)) = (X1 * (X2 * (X3 + (X2 * X3))))))).
+step(add(rule(334, ((X1 + X1) * (X2 + (X1 * ((X1 + X1) * X2)))) = 0))).
+step(add(rule(335, (X1 * (X1 * ((X1 + X2) * X2))) = (X1 * ((X2 + X1) * (X2 * X2)))))).
+step(add(rule(336, (X1 * (X2 + (X1 * (X3 * X2)))) = (X1 * (X1 * ((X3 + X1) * X2)))))).
+step(add(rule(337, (X1 * ((X1 + X2) * (X1 * X2))) = (X1 * (X2 * ((X2 + X1) * X2)))))).
+step(add(rule(338, (X1 * (X2 + (X3 * (X1 * X2)))) = (X1 * ((X3 + X1) * (X1 * X2)))))).
+step(add(rule(339, (X1 * -(X2 + (X1 * (X1 * -X2)))) = 0))).
+step(add(rule(340, ((X1 + (X1 * (X2 * X3))) * X3) = (X1 * ((X3 + X2) * (X3 * X3)))))).
+step(add(rule(341, ((X1 + (X1 * (X2 * -X2))) * X2) = 0))).
+step(add(rule(342, ((X1 + (X1 * (X2 * -X2))) * -X2) = 0))).
+step(add(rule(343, ((X1 + (X1 * (X2 * X3))) * X2) = (X1 * (X2 * ((X2 + X3) * X2)))))).
+step(add(rule(344, (X1 * -((X1 * X1) + X2)) = -(X1 + (X1 * X2))))).
+step(add(rule(345, (((X1 * X1) + X2) * -X1) = -(X1 + (X2 * X1))))).
+step(add(rule(346, ((X1 * X2) + ((X3 + X1) * X4)) = ((X1 * (X4 + X2)) + (X3 * X4))))).
+step(hard((X1 * (X2 + (X3 + X2))) = (X1 * (X3 + (X2 + X2))))).
+step(hard((X1 * (X2 + (X3 + X2))) = (X1 * (X2 + (X2 + X3))))).
+step(add(rule(347, ((X1 * -X2) + ((X3 + X1) * X2)) = (X3 * X2)))).
+step(add(rule(348, ((X1 * X2) + ((X3 + X1) * X4)) = ((X3 * X4) + (X1 * (X2 + X4)))))).
+step(add(rule(349, (X1 * (X2 + -(X3 + X2))) = (X1 * -X3)))).
+step(add(rule(350, ((X1 + -(X3 + X1)) * X2) = (X3 * -X2)))).
+step(add(rule(351, (((X1 * X2) + (X4 + X1)) * X3) = ((X4 + (X1 + (X1 * X2))) * X3)))).
+step(interreduce).
+step(delete(rule(103, ((X1 + (X1 + X1)) * (X1 * X1)) = (X1 + (X1 + X1))))).
+step(delete(rule(153, (((X1 + X1) * -X2) + X3) = ((X1 * -(X2 + X2)) + X3)))).
+step(delete(rule(168, (X1 * (((X2 + X2) * X3) + X4)) = (X1 * ((X2 * (X3 + X3)) + X4))))).
+step(delete(rule(171, (X1 + (X2 + (X1 * (X1 * X3)))) = (X2 + (X1 * (X1 * (X1 + X3))))))).
+step(delete(rule(174, (X1 + (X2 + (X1 * (X3 * X1)))) = (X2 + (X1 * ((X1 + X3) * X1)))))).
+step(delete(rule(180, (X1 * (X2 + (X1 * (X3 * X2)))) = (X1 * (X1 * ((X1 + X3) * X2)))))).
+step(delete(rule(181, (X1 * (X2 + (X3 * (X1 * X2)))) = (X1 * ((X1 + X3) * (X1 * X2)))))).
+step(delete(rule(189, ((X1 * X2) + (X3 * (X2 + X4))) = ((X3 * X4) + ((X1 + X3) * X2))))).
+step(delete(rule(216, ((X1 + X1) * (X2 + X2)) = (X1 * ((X1 + X1) * ((X1 + X1) * X2)))))).
+step(add(rule(352, (X1 * -(X2 + X2)) = (X1 * ((X1 + X1) * ((X1 + X1) * X2)))))).
+step(delete(rule(217, ((X1 + X1) * ((X1 + X1) * (X2 + X2))) = (X1 * ((X1 + X1) * X2))))).
+step(delete(rule(262, (X1 * (X2 + (X3 * X2))) = (X1 * (X1 * ((X1 + (X1 * X3)) * X2)))))).
+step(delete(rule(270, ((X1 + X1) * (X1 + X1)) = (X1 * -(X1 + X1))))).
+step(delete(rule(288, (((X1 + (X1 + X1)) * X2) + (((X1 + (X1 + X1)) * X2) + X3)) = X3))).
+step(delete(rule(293, ((X1 + (X1 + X1)) * (X1 * ((X1 + X1) * X2))) = 0))).
+step(delete(rule(294, ((X1 + (X1 + X1)) * (X1 * -(X1 + X1))) = 0))).
+step(delete(rule(304, (((X1 * (X2 * X2)) + X3) * (X2 * X4)) = ((X1 + X3) * (X2 * X4))))).
+step(delete(rule(306, (X1 * ((X1 * -X1) + X2)) = (-X1 + (X1 * X2))))).
+step(delete(rule(341, ((X1 + (X1 * (X2 * -X2))) * X2) = 0))).
+step(add(rule(353, (X1 * ((X1 + X1) * ((X1 + X1) * X2))) = ((X1 + X1) * -X2)))).
+step(add(rule(354, (X1 + (X1 + (X1 * (X2 + X2)))) = ((X1 + X1) * (X2 + (X1 * X1)))))).
+step(add(rule(355, (X1 + (X1 * ((X1 * X3) + X2))) = (X1 * (X2 + (X1 * (X3 + X1))))))).
+step(add(rule(356, (X1 * (X2 + (X1 * (X2 + X1)))) = (X1 + ((X1 + (X1 * X1)) * X2))))).
+step(add(rule(357, (X1 + (X1 * ((X3 * X1) + X2))) = (X1 * (X2 + ((X3 + X1) * X1)))))).
+step(add(rule(358, (((X1 * -X1) + X2) * -X1) = (X1 + (X2 * -X1))))).
+step(add(rule(359, ((X1 + (X2 * -X2)) * X2) = (-X2 + (X1 * X2))))).
+step(hard((X1 + ((X2 * (X1 * X1)) + X3)) = (X3 + ((X2 + X1) * (X1 * X1))))).
+step(add(rule(360, (X1 + ((X2 + X3) * (X2 * X2))) = (X2 + (X1 + (X3 * (X2 * X2))))))).
+step(hard((X1 + ((X2 + X3) * (X3 * X3))) = (X1 + ((X3 + X2) * (X3 * X3))))).
+step(add(rule(361, (X2 + (((X3 * X2) + X1) * X2)) = ((X1 + ((X2 + X3) * X2)) * X2)))).
+step(add(rule(362, ((X1 + ((X2 + X1) * X2)) * X2) = (X2 + (X1 * (X2 + (X2 * X2))))))).
+step(add(rule(363, ((X1 + ((X1 * X1) + X2)) * (X1 * X1)) = ((X1 + ((X1 + X2) * X1)) * X1)))).
+step(add(rule(364, ((X2 + (X1 + (X1 * X1))) * (X1 * X1)) = ((X1 + ((X1 + X2) * X1)) * X1)))).
+step(add(rule(365, ((X1 + (X1 * X3)) * (X2 + X2)) = ((X1 + X1) * (X2 + (X3 * X2)))))).
+step(add(rule(366, (X2 + (((X2 * X3) + X1) * X2)) = ((X1 + (X2 * (X2 + X3))) * X2)))).
+step(add(rule(367, ((X1 + (X1 + (X1 + X2))) * (X3 + X3)) = (X2 * (X3 + X3))))).
+step(add(rule(368, ((X1 + ((X2 * X2) + X3)) * (X2 * X2)) = ((X2 + ((X1 + X3) * X2)) * X2)))).
+step(add(rule(369, (X1 * ((X2 * (X3 + X3)) + X4)) = (X1 * (((X2 + X2) * X3) + X4))))).
+step(hard((X1 + X2) = (X3 + (X4 + (X1 + (X2 + -(X4 + X3))))))).
+step(add(rule(370, ((X3 + ((X1 * X1) + X2)) * X1) = (X1 + ((X2 + X3) * X1))))).
+step(add(rule(371, (((X1 * (X1 + X1)) + X2) * X1) = (X1 + (X1 + (X2 * X1)))))).
+step(add(rule(372, (X1 * (X2 + (X3 + (X3 * (X1 * -X1))))) = (X1 * X2)))).
+step(add(rule(373, ((X1 + X1) * ((X2 + X2) * -X3)) = (X1 * ((X2 + X2) * X3))))).
+step(add(rule(374, ((X1 + X1) * (-(X2 + X2) + X3)) = ((X1 + X1) * (X2 + X3))))).
+step(add(rule(375, ((X1 + X1) * (X2 + -(X3 + X3))) = ((X1 + X1) * (X2 + X3))))).
+step(add(rule(376, ((X1 + X1) * (X2 * -(X3 + X3))) = (X1 * (X2 * (X3 + X3)))))).
+step(add(rule(377, ((X1 + (X1 * (X2 * (X2 + X2)))) * ((X2 + X2) * X3)) = 0))).
+step(add(rule(378, ((X1 + (X1 + X1)) * (X2 + (X3 + (X2 + X3)))) = 0))).
+step(add(rule(379, ((X1 + (X1 + X1)) * (X2 + (X2 + (X3 + X3)))) = 0))).
+step(add(rule(380, (X1 * (-X2 + (X1 * ((X1 + X1) * X2)))) = (X1 * X2)))).
+step(add(rule(381, ((X1 + (X1 + X1)) * -X2) = ((X1 + (X1 + X1)) * X2)))).
+step(add(rule(382, ((-X1 + (X1 * (X2 * (X2 + X2)))) * X2) = (X1 * X2)))).
+step(add(rule(383, (X1 * ((X1 * (X1 + X1)) + X2)) = (X1 + (X1 + (X1 * X2)))))).
+step(hard((((X1 * X1) + (X2 + X1)) * X1) = (X1 + ((X2 + X1) * X1)))).
+step(hard(((X1 + (-X1 + (X3 + X1))) * X2) = ((X3 + X1) * X2))).
+step(add(rule(384, (X2 + (-(X2 + (X3 * X2)) + ((X1 + (X3 + (X1 * X3))) * X2))) = (X1 * (X2 + (X3 * X2)))))).
+step(add(rule(385, (X2 + (X2 + (X2 + (X2 + (X2 + (X2 + ((X1 + (X1 + X1)) * X2))))))) = (X1 * (X2 + (X2 + X2)))))).
+step(add(rule(386, ((X2 * -X3) + ((X2 + (X2 + (X1 * X2))) * X3)) = ((X2 + (X1 * X2)) * X3)))).
+step(add(rule(387, (((X1 + X1) * X2) + X3) = (? + (? + (X3 + (-(? + ?) + (X1 * (X2 + X2))))))))).
+step(add(rule(388, (X4 + (X5 + (X3 + (-(X4 + X5) + (X1 * (X2 + X2)))))) = (? + (? + (X3 + (-(? + ?) + (X1 * (X2 + X2))))))))).
+step(add(rule(389, (((X1 + X1) * X2) + X3) = ((X1 * (X2 + X2)) + X3)))).
+step(add(rule(390, ((X1 * (X2 + X2)) + X3) = (? + (? + (X3 + (-(? + ?) + ((X1 + X1) * X2)))))))).
+step(add(rule(391, (X4 + (X5 + (X3 + (-(X4 + X5) + ((X1 + X1) * X2))))) = (? + (? + (X3 + (-(? + ?) + ((X1 + X1) * X2)))))))).
+step(add(rule(392, (X1 * (X2 * (X3 + (X3 * (X1 * -X1))))) = 0))).
+step(add(rule(393, (X1 * (X2 * (X3 + (X1 * (X1 * -X3))))) = 0))).
+step(add(rule(394, ((X1 + (X1 + X1)) * (X2 * -(X3 + X3))) = 0))).
+step(add(rule(395, ((X1 + (X1 * (X2 * (X2 + X2)))) * -(X2 + X2)) = 0))).
+step(add(rule(396, ((X3 * -X2) + ((X3 + X1) * X2)) = (X1 * X2)))).
+step(add(rule(397, ((X1 + X1) * ((X1 + X1) * X2)) = (X1 * ((X1 + X1) * -X2))))).
+step(add(rule(398, ((X1 + X1) * (X2 + (X2 * (X1 * -X1)))) = 0))).
+step(add(rule(399, (X1 * (X2 * (X3 + (X1 * (X2 * (X1 * X2)))))) = (X1 * (X2 + (X2 * X3)))))).
+step(add(rule(400, (X1 + (X2 + (X3 * ((X1 + X2) * (X1 + X2))))) = ((X1 + (X2 + X3)) * ((X1 + X2) * (X1 + X2)))))).
+step(add(rule(401, ((X1 + (X2 + (X1 + X2))) * ((X1 + X2) * (X1 + X2))) = (X1 + (X2 + (X1 + X2)))))).
+step(add(rule(402, ((X1 * X2) + (X3 * (X1 * (X2 * (X1 * X2))))) = (((X1 * X2) + X3) * (X1 * (X2 * (X1 * X2))))))).
+step(add(rule(403, (X1 * ((X1 + (X2 * X1)) * (X2 * (X1 * X2)))) = (X1 * (X2 + (X1 * (X2 * (X1 * X2)))))))).
+step(add(rule(404, ((X1 + (X1 * (X2 * -X2))) * (X3 * X2)) = 0))).
+step(add(rule(405, (X1 * (X3 * (X3 * (X2 * X3)))) = (X1 * (X2 * X3))))).
+step(add(rule(406, ((X3 * X4) + (X1 * (X2 * (X3 * (X3 * X4))))) = (((X1 * X2) + X3) * (X3 * (X3 * X4)))))).
+step(add(rule(407, ((X2 + -X1) * (X3 + X3)) = ((X2 + (-(X1 + X1) + X2)) * X3)))).
+step(add(rule(408, ((X1 + X1) * (X3 + -X2)) = (X1 * (X3 + (-(X2 + X2) + X3)))))).
+step(add(rule(409, ((X1 + (((X2 * -X2) + X1) * (X2 * -X2))) * (X2 * -X2)) = (X2 * -X2)))).
+step(add(rule(410, (X1 * (X2 + (X1 * ((X1 + X1) * -X2)))) = (X1 * -X2)))).
+step(add(rule(411, ((X1 + (X1 + X2)) * -(X3 + X3)) = ((X1 + -X2) * (X3 + X3))))).
+step(add(rule(412, ((X1 + X1) * ((X2 + X2) * X3)) = (X1 * ((X2 + X2) * -X3))))).
+step(add(rule(413, ((X1 + X1) * (X2 + (X2 + X3))) = ((X1 + X1) * (X3 + -X2))))).
+step(add(rule(414, ((X1 + X1) * (X2 + (X1 * ((X1 + X1) * X3)))) = ((X1 + X1) * (X2 + -X3))))).
+step(add(rule(415, ((X2 + (X2 * (X3 * -X3))) * X3) = 0))).
+step(add(rule(416, ((X2 + (X2 + X1)) * (X3 + X3)) = ((X1 + -X2) * (X3 + X3))))).
+step(add(rule(417, ((X1 + X1) * (X2 + (X3 + X3))) = ((X1 + X1) * (X2 + -X3))))).
+step(add(rule(418, ((X1 + (X2 * -(X2 + X2))) * X2) = ((X1 * X2) + -(X2 + X2))))).
+step(add(rule(419, ((X1 + (X2 * (X2 * -X1))) * -X2) = 0))).
+step(add(rule(420, (X1 * (X1 * (X2 * X1))) = (X2 * X1)))).
+step(add(rule(421, (X2 * (X2 * (X1 * -X2))) = (X1 * -X2)))).
+step(add(rule(422, ((X1 + (X2 * (X2 * -X1))) * X2) = 0))).
+step(add(rule(423, ((X1 + X2) * ((X3 + X3) * X4)) = ((X1 + (X2 + (X1 + X2))) * (X3 * X4))))).
+step(add(rule(424, ((X1 + (X2 + (X1 + X2))) * (X3 + (X3 + X3))) = 0))).
+step(add(rule(425, ((X1 + X2) * ((X3 + X3) * X4)) = ((X1 + (X1 + (X2 + X2))) * (X3 * X4))))).
+step(hard(((X1 + X2) * ((X3 + X3) * X4)) = ((X2 + X1) * (X3 * (X4 + X4))))).
+step(add(rule(426, ((X1 + -(X2 + X2)) * (X3 + X3)) = ((X1 + X2) * (X3 + X3))))).
+step(add(rule(427, (X1 * ((X2 + X2) * (X3 + (X2 * X2)))) = ((X1 + X1) * (X2 + (X2 * X3)))))).
+step(add(rule(428, ((X1 + X1) * ((X2 + X3) * X4)) = (X1 * ((X2 + (X3 + (X2 + X3))) * X4))))).
+step(add(rule(429, (X1 * (((X2 + X2) * X3) + X4)) = (((X1 + X1) * (X2 * X3)) + (X1 * X4))))).
+step(add(rule(430, (X1 + ((X1 + X1) * (X2 * X3))) = (X1 + (X1 * ((X2 + X2) * X3)))))).
+step(add(rule(431, (X1 * (X2 + ((X3 + X3) * X4))) = ((X1 * X2) + ((X1 + X1) * (X3 * X4)))))).
+step(add(rule(432, (X1 * (X2 + (X1 * -(X1 + X1)))) = ((X1 * X2) + -(X1 + X1))))).
+step(add(rule(433, ((X1 + X1) * ((X2 + X3) * X4)) = (X1 * ((X2 + (X2 + (X3 + X3))) * X4))))).
+step(hard(((X1 + X1) * ((X2 + X3) * X4)) = (X1 * ((X3 + X2) * (X4 + X4))))).
+step(add(rule(434, (X1 * ((X2 + X2) * (X3 + X4))) = (X1 * (X2 * (X3 + (X4 + (X3 + X4)))))))).
+step(add(rule(435, (X1 * ((X2 + X2) * (X3 + X4))) = (X1 * (X2 * (X3 + (X3 + (X4 + X4)))))))).
+step(hard((X1 * ((X2 + X2) * (X3 + X4))) = (X1 * ((X2 + X2) * (X4 + X3))))).
+step(add(rule(436, (X1 * ((X2 + X3) * (X4 + X4))) = (X1 * ((X2 + (X3 + (X2 + X3))) * X4))))).
+step(add(rule(437, (X1 * ((X2 + X3) * (X4 + X4))) = (X1 * ((X2 + (X2 + (X3 + X3))) * X4))))).
+step(interreduce).
+step(delete(rule(194, (X1 + (X1 + (X1 * (X2 + X2)))) = ((X1 + X1) * ((X1 * X1) + X2))))).
+step(delete(rule(207, ((X1 + (X2 + (X1 * X1))) * (X1 * X1)) = ((X1 + ((X1 + X2) * X1)) * X1)))).
+step(delete(rule(240, ((X1 + X1) * ((X2 + (X1 * X1)) * X3)) = ((X1 + X1) * (X3 + (X2 * X3)))))).
+step(delete(rule(241, ((X2 + ((X1 * X1) + X2)) * X1) = (X1 + (X2 * (X1 + X1)))))).
+step(delete(rule(245, ((X1 + (X1 * (X2 * -X2))) * (X2 + X2)) = 0))).
+step(delete(rule(278, (X1 * (X2 + (X2 + X2))) = ((X1 + (X1 + X1)) * -X2)))).
+step(delete(rule(279, ((X1 + X1) * (X2 + (X2 + X2))) = 0))).
+step(delete(rule(281, ((X1 + (X1 + X1)) * (X2 + X2)) = 0))).
+step(delete(rule(282, ((X1 + (X1 + X1)) * -(X2 + X2)) = 0))).
+step(delete(rule(290, ((X1 + (X1 * (X2 * (X2 + X2)))) * (X2 + X2)) = 0))).
+step(delete(rule(312, ((X1 + X1) * ((X2 + X2) * X3)) = (X1 * (X2 * -(X3 + X3)))))).
+step(delete(rule(334, ((X1 + X1) * (X2 + (X1 * ((X1 + X1) * X2)))) = 0))).
+step(delete(rule(352, (X1 * -(X2 + X2)) = (X1 * ((X1 + X1) * ((X1 + X1) * X2)))))).
+step(delete(rule(353, (X1 * ((X1 + X1) * ((X1 + X1) * X2))) = ((X1 + X1) * -X2)))).
+step(delete(rule(363, ((X1 + ((X1 * X1) + X2)) * (X1 * X1)) = ((X1 + ((X1 + X2) * X1)) * X1)))).
+step(delete(rule(367, ((X1 + (X1 + (X1 + X2))) * (X3 + X3)) = (X2 * (X3 + X3))))).
+step(delete(rule(373, ((X1 + X1) * ((X2 + X2) * -X3)) = (X1 * ((X2 + X2) * X3))))).
+step(delete(rule(374, ((X1 + X1) * (-(X2 + X2) + X3)) = ((X1 + X1) * (X2 + X3))))).
+step(delete(rule(378, ((X1 + (X1 + X1)) * (X2 + (X3 + (X2 + X3)))) = 0))).
+step(delete(rule(386, ((X2 * -X3) + ((X2 + (X2 + (X1 * X2))) * X3)) = ((X2 + (X1 * X2)) * X3)))).
+step(delete(rule(397, ((X1 + X1) * ((X1 + X1) * X2)) = (X1 * ((X1 + X1) * -X2))))).
+step(delete(rule(401, ((X1 + (X2 + (X1 + X2))) * ((X1 + X2) * (X1 + X2))) = (X1 + (X2 + (X1 + X2)))))).
+step(add(rule(438, ((X1 + X2) * ((X1 + X2) * (X1 + (X1 + (X2 + X2))))) = (X1 + (X2 + (X1 + X2)))))).
+step(delete(rule(404, ((X1 + (X1 * (X2 * -X2))) * (X3 * X2)) = 0))).
+step(delete(rule(405, (X1 * (X3 * (X3 * (X2 * X3)))) = (X1 * (X2 * X3))))).
+step(delete(rule(413, ((X1 + X1) * (X2 + (X2 + X3))) = ((X1 + X1) * (X3 + -X2))))).
+step(delete(rule(423, ((X1 + X2) * ((X3 + X3) * X4)) = ((X1 + (X2 + (X1 + X2))) * (X3 * X4))))).
+step(delete(rule(428, ((X1 + X1) * ((X2 + X3) * X4)) = (X1 * ((X2 + (X3 + (X2 + X3))) * X4))))).
+step(delete(rule(434, (X1 * ((X2 + X2) * (X3 + X4))) = (X1 * (X2 * (X3 + (X4 + (X3 + X4)))))))).
+step(delete(rule(436, (X1 * ((X2 + X3) * (X4 + X4))) = (X1 * ((X2 + (X3 + (X2 + X3))) * X4))))).
+step(hard((X1 * ((X2 + X3) * (X4 + X4))) = (X1 * ((X3 + X2) * (X4 + X4))))).
+step(add(rule(439, ((X1 * X2) + (X3 * -(X2 + X2))) = ((X1 + -(X3 + X3)) * X2)))).
+step(add(rule(440, ((X1 + (X2 + X2)) * X3) = ((X1 * X3) + (X2 * (X3 + X3)))))).
+step(hard((((X1 + X1) * X2) + (X1 * -(X2 + X2))) = 0)).
+step(add(rule(441, ((X1 + X2) * (X3 + (X4 * X3))) = ((X1 + (X2 + ((X1 + X2) * X4))) * X3)))).
+step(add(rule(442, ((X1 + ((X1 * X2) + X3)) * X4) = ((X1 * (X4 + (X2 * X4))) + (X3 * X4))))).
+step(add(rule(443, ((X1 + (X2 + (X2 * X3))) * X4) = ((X1 * X4) + (X2 * (X4 + (X3 * X4))))))).
+step(add(rule(444, ((X1 + X1) * (X2 + (X3 * X2))) = ((X1 + (X1 + (X1 * (X3 + X3)))) * X2)))).
+step(add(rule(445, (X1 * (X2 + ((X3 + (X1 * X1)) * X2))) = ((X1 + (X1 + (X1 * X3))) * X2)))).
+step(add(rule(446, ((X1 + (X1 * X2)) * (X3 + X4)) = (X1 * (X3 + (X4 + (X2 * (X3 + X4)))))))).
+step(add(rule(447, (X1 * (X2 + ((X3 * X2) + X4))) = (((X1 + (X1 * X3)) * X2) + (X1 * X4))))).
+step(add(rule(448, (X1 * (-X2 + (X3 * X2))) = ((-X1 + (X1 * X3)) * X2)))).
+step(add(rule(449, (X1 + (X1 * (X2 + (X3 * X2)))) = (X1 + ((X1 + (X1 * X3)) * X2))))).
+step(add(rule(450, (X1 * ((X2 * X3) + ((X2 * -X3) + X4))) = (X1 * X4)))).
+step(add(rule(451, (X1 * (X2 * (X3 * (X1 * X1)))) = (X1 * (X2 * X3))))).
+step(add(rule(452, (X1 * (X2 * (X1 * X1))) = (X1 * X2)))).
+step(add(rule(453, (X1 * (X2 * (X1 * -X1))) = (X1 * -X2)))).
+step(add(rule(454, (X1 * (X2 + (X3 * (X1 * X1)))) = (X1 * (X2 + X3))))).
+step(add(rule(455, (X1 * (X2 * (X1 * (X1 + X1)))) = ((X1 + X1) * X2)))).
+step(add(rule(456, (X1 * ((X1 + (X2 * X1)) * X1)) = (X1 + (X1 * X2))))).
+step(add(rule(457, (X1 * (X2 * (X1 * X2))) = (X1 * (X2 * (X2 * X1)))))).
+step(add(rule(458, ((X1 + (X2 * X1)) * X1) = (X1 * (X1 + (X1 * X2)))))).
+step(add(rule(459, (X1 * (X2 + (X3 + (X4 * X3)))) = ((X1 * X2) + ((X1 + (X1 * X4)) * X3))))).
+step(add(rule(460, (X1 * (X2 + (X3 + X3))) = ((X1 * X2) + ((X1 + X1) * X3))))).
+step(add(rule(461, (X1 * ((X1 * X1) + (X2 + X2))) = (X1 + ((X1 + X1) * X2))))).
+step(add(rule(462, ((X1 + (X2 + X1)) * (X3 + X3)) = ((X2 + -X1) * (X3 + X3))))).
+step(add(rule(463, ((X2 + (X1 + X1)) * (X3 + X3)) = ((X2 + -X1) * (X3 + X3))))).
+step(add(rule(464, ((X1 + X1) * (X3 + (X2 * X3))) = (X1 * (X3 + (X3 + ((X2 + X2) * X3))))))).
+step(add(rule(465, (X1 * -(X2 + (X1 * (X1 * X3)))) = (X1 * -(X2 + X3))))).
+step(add(rule(466, ((X3 * X5) + (X1 + (X2 + (X3 * X4)))) = (X1 + (X2 + (X3 * (X4 + X5))))))).
+step(add(rule(467, (X1 + (X2 * (X3 + (X4 + X4)))) = (((X2 + X2) * X4) + (X1 + (X2 * X3)))))).
+step(add(rule(468, (X1 + (X2 * (X3 + (X3 + X3)))) = (X1 + ((X2 + (X2 + X2)) * X3))))).
+step(add(rule(469, (X1 + (X2 * (X3 + (X3 + X4)))) = ((X2 * X4) + (X1 + ((X2 + X2) * X3)))))).
+step(add(rule(470, (X1 + (X2 + (X2 * (X3 + X3)))) = (X2 + (X1 + ((X2 + X2) * X3)))))).
+step(hard((X1 * (X2 + (X3 + (X3 + X4)))) = (X1 * (X4 + (X3 + (X3 + X2)))))).
+step(add(rule(471, ((X2 * X3) + ((X1 + X2) * (X1 * X1))) = (X1 + (X2 * ((X1 * X1) + X3)))))).
+step(add(rule(472, ((X4 * X5) + (X1 + (X2 + (X3 * X5)))) = (X1 + (X2 + ((X3 + X4) * X5)))))).
+step(add(rule(473, (X1 + ((X2 + (X3 + X3)) * X4)) = ((X3 * (X4 + X4)) + (X1 + (X2 * X4)))))).
+step(add(rule(474, ((X1 + X1) * (X2 + (X3 + X2))) = ((X1 + X1) * (X3 + -X2))))).
+step(add(rule(475, (X1 + ((X2 + (X2 + X3)) * X4)) = ((X3 * X4) + (X1 + (X2 * (X4 + X4))))))).
+step(hard(((X1 + (X3 + (X3 + X4))) * X2) = ((X4 + (X3 + (X3 + X1))) * X2))).
+step(add(rule(476, ((X1 + (X1 + X2)) * (X3 * X4)) = (((X1 * (X3 + X3)) + (X2 * X3)) * X4)))).
+step(add(rule(477, (X1 * ((X2 * (X3 + X3)) + (X4 * X3))) = (X1 * ((X2 + (X2 + X4)) * X3))))).
+step(add(rule(478, ((X1 * (X2 + X2)) + ((X3 + X4) * X2)) = ((X1 + (X3 + (X1 + X4))) * X2)))).
+step(hard(((X1 + (X2 + (X1 + X3))) * X4) = ((X1 + (X1 + (X2 + X3))) * X4))).
+step(add(rule(479, ((X1 * (X2 + X2)) + ((X3 * X2) + X4)) = (((X1 + (X1 + X3)) * X2) + X4)))).
+step(hard(((X1 + (X1 + (X2 + X4))) * X3) = ((X2 + (X4 + (X1 + X1))) * X3))).
+step(add(rule(480, (((X1 * X2) + ((X1 * X2) + X3)) * X4) = ((X1 * (X2 * (X4 + X4))) + (X3 * X4))))).
+step(add(rule(481, (((X1 * X2) + ((X1 * X2) + X3)) * X4) = (((X1 * (X2 + X2)) + X3) * X4)))).
+step(add(rule(482, ((X1 * (X2 + X2)) + (X3 + (X4 * X2))) = (X3 + ((X1 + (X1 + X4)) * X2))))).
+step(hard((X1 + ((X2 + (X2 + X3)) * X4)) = (X1 + ((X3 + (X2 + X2)) * X4)))).
+step(hard(((X1 + (X3 + (X3 + X4))) * X2) = ((X3 + (X3 + (X1 + X4))) * X2))).
+step(add(rule(483, ((X1 * (X2 + X2)) + ((X3 + X4) * X2)) = ((X4 + (X1 + (X1 + X3))) * X2)))).
+step(add(rule(484, ((-? + (X2 + (X2 + ?))) * X3) = (X2 * (X3 + X3))))).
+step(add(rule(485, ((-X1 + (X2 + (X2 + X1))) * X3) = ((-? + (X2 + (X2 + ?))) * X3)))).
+step(hard(((X1 + (X2 + (X2 + X3))) * X4) = ((X2 + (X2 + (X3 + X1))) * X4))).
+step(hard(((X1 + (X2 + (X2 + X3))) * X4) = ((X2 + (X3 + (X2 + X1))) * X4))).
+step(add(rule(486, (X1 * (((X2 + X2) * X3) + (X2 * X4))) = (X1 * (X2 * (X3 + (X3 + X4))))))).
+step(add(rule(487, (X1 * ((X2 + (X2 + X3)) * X4)) = ((((X1 + X1) * X2) + (X1 * X3)) * X4)))).
+step(add(rule(488, ((X1 + (X1 + X1)) * (X2 * X3)) = (X1 * (X2 * (X3 + (X3 + X3))))))).
+step(add(rule(489, (((X1 + X1) * X2) + (X1 * (X3 + X4))) = (X1 * (X2 + (X3 + (X2 + X4))))))).
+step(hard((X1 * (X2 + (X3 + (X2 + X4)))) = (X1 * (X2 + (X2 + (X3 + X4)))))).
+step(add(rule(490, (((X1 + X1) * X2) + ((X1 * X3) + X4)) = ((X1 * (X2 + (X2 + X3))) + X4)))).
+step(hard((X1 * (X2 + (X2 + (X3 + X4)))) = (X1 * (X3 + (X4 + (X2 + X2)))))).
+step(add(rule(491, ((X1 * (X2 + X2)) + ((X1 * -(X2 + X2)) + X3)) = X3))).
+step(add(rule(492, (((X1 + X1) * X2) + (X3 + (X1 * X4))) = (X3 + (X1 * (X2 + (X2 + X4))))))).
+step(hard((X1 + (X2 * (X3 + (X3 + X4)))) = (X1 + (X2 * (X4 + (X3 + X3)))))).
+step(hard((X1 * (X2 + (X3 + (X3 + X4)))) = (X1 * (X3 + (X3 + (X2 + X4)))))).
+step(add(rule(493, (X1 * (X2 + (X2 + ((X3 + X3) * X4)))) = ((X1 + X1) * (X2 + (X3 * X4)))))).
+step(add(rule(494, (X1 * (X2 + X2)) = ((X1 + X1) * (X2 + (? + (? + ?))))))).
+step(add(rule(495, ((X1 + X1) * (X2 + (X3 + (X3 + X3)))) = ((X1 + X1) * (X2 + (? + (? + ?))))))).
+step(add(rule(496, ((X1 + X1) * (X2 + -X3)) = (X1 * (X2 + (X2 + -(X3 + X3))))))).
+step(add(rule(497, (X1 * (X1 * (X2 + (X2 + (X1 * X3))))) = (X1 * (((X1 + X1) * X2) + X3))))).
+step(add(rule(498, (((X1 + X1) * X2) + (X1 * (X3 + X4))) = (X1 * (X4 + (X2 + (X2 + X3))))))).
+step(add(rule(499, (X1 * (-? + (X3 + (X3 + ?)))) = ((X1 + X1) * X3)))).
+step(add(rule(500, (X1 * (-X2 + (X3 + (X3 + X2)))) = (X1 * (-? + (X3 + (X3 + ?))))))).
+step(hard((X1 * (X2 + (X3 + (X3 + X4)))) = (X1 * (X3 + (X3 + (X4 + X2)))))).
+step(hard((X1 * (X2 + (X3 + (X3 + X4)))) = (X1 * (X3 + (X4 + (X3 + X2)))))).
+step(add(rule(501, (X1 * (X3 + (X4 + ((X1 * X1) + X2)))) = (X1 + (X1 * (X2 + (X3 + X4))))))).
+step(add(rule(502, (X1 * ((X2 + ((X1 * X1) + X3)) * X4)) = ((X1 + (X1 * (X3 + X2))) * X4)))).
+step(add(rule(503, (X1 * (X2 + (X3 + (X4 + (X1 * X1))))) = (X1 + (X1 * (X2 + (X3 + X4))))))).
+step(add(rule(504, (X1 * ((X2 + (X3 + (X1 * X1))) * X4)) = ((X1 + (X1 * (X2 + X3))) * X4)))).
+step(hard(((X1 + (X1 * (X2 + X3))) * X4) = ((X1 + (X1 * (X3 + X2))) * X4))).
+step(add(rule(505, ((X1 + (X1 * X2)) * ((X2 + (X1 * X1)) * (X2 + (X1 * X1)))) = (X1 + (X1 * X2))))).
+step(interreduce).
+step(delete(rule(162, (((? * X2) + ((? * X2) + ((? + X3) * -(X2 + X2)))) * X4) = (X3 * (X2 * -(X4 + X4)))))).
+step(delete(rule(163, (((X1 * X2) + ((X1 * X2) + ((X3 + X1) * -(X2 + X2)))) * X4) = (((? * X2) + ((? * X2) + ((? + X3) * -(X2 + X2)))) * X4)))).
+step(delete(rule(249, (X1 * (-X2 + (X2 * (X1 * X1)))) = 0))).
+step(delete(rule(287, (((X1 + X1) * X2) + (((X1 + X1) * X2) + (((X1 + X1) * X2) + X3))) = X3))).
+step(delete(rule(319, (X1 * (X2 + (X2 * (X1 * X1)))) = ((X1 + X1) * X2)))).
+step(delete(rule(339, (X1 * -(X2 + (X1 * (X1 * -X2)))) = 0))).
+step(delete(rule(364, ((X2 + (X1 + (X1 * X1))) * (X1 * X1)) = ((X1 + ((X1 + X2) * X1)) * X1)))).
+step(add(rule(506, ((X2 + (X1 + (X1 * X1))) * (X1 * X1)) = (X1 * (X1 + (X1 * (X1 + X2))))))).
+step(delete(rule(368, ((X1 + ((X2 * X2) + X3)) * (X2 * X2)) = ((X2 + ((X1 + X3) * X2)) * X2)))).
+step(add(rule(507, ((X1 + ((X2 * X2) + X3)) * (X2 * X2)) = (X2 * (X2 + (X2 * (X1 + X3))))))).
+step(delete(rule(408, ((X1 + X1) * (X3 + -X2)) = (X1 * (X3 + (-(X2 + X2) + X3)))))).
+step(delete(rule(416, ((X2 + (X2 + X1)) * (X3 + X3)) = ((X1 + -X2) * (X3 + X3))))).
+step(delete(rule(456, (X1 * ((X1 + (X2 * X1)) * X1)) = (X1 + (X1 * X2))))).
+step(delete(rule(464, ((X1 + X1) * (X3 + (X2 * X3))) = (X1 * (X3 + (X3 + ((X2 + X2) * X3))))))).
+step(delete(rule(467, (X1 + (X2 * (X3 + (X4 + X4)))) = (((X2 + X2) * X4) + (X1 + (X2 * X3)))))).
+step(delete(rule(473, (X1 + ((X2 + (X3 + X3)) * X4)) = ((X3 * (X4 + X4)) + (X1 + (X2 * X4)))))).
+step(delete(rule(480, (((X1 * X2) + ((X1 * X2) + X3)) * X4) = ((X1 * (X2 * (X4 + X4))) + (X3 * X4))))).
+step(delete(rule(484, ((-? + (X2 + (X2 + ?))) * X3) = (X2 * (X3 + X3))))).
+step(add(rule(508, ((? + (-? + (X2 + X2))) * X3) = (X2 * (X3 + X3))))).
+step(delete(rule(485, ((-X1 + (X2 + (X2 + X1))) * X3) = ((-? + (X2 + (X2 + ?))) * X3)))).
+step(add(rule(509, ((-X1 + (X2 + (X2 + X1))) * X3) = ((? + (-? + (X2 + X2))) * X3)))).
+step(delete(rule(494, (X1 * (X2 + X2)) = ((X1 + X1) * (X2 + (? + (? + ?))))))).
+step(add(rule(510, (X1 * (X2 + X2)) = ((X1 + X1) * (? + (? + (? + X2))))))).
+step(delete(rule(495, ((X1 + X1) * (X2 + (X3 + (X3 + X3)))) = ((X1 + X1) * (X2 + (? + (? + ?))))))).
+step(add(rule(511, ((X1 + X1) * (X2 + (X3 + (X3 + X3)))) = ((X1 + X1) * (? + (? + (? + X2))))))).
+step(delete(rule(499, (X1 * (-? + (X3 + (X3 + ?)))) = ((X1 + X1) * X3)))).
+step(add(rule(512, (X1 * (? + (-? + (X3 + X3)))) = ((X1 + X1) * X3)))).
+step(delete(rule(500, (X1 * (-X2 + (X3 + (X3 + X2)))) = (X1 * (-? + (X3 + (X3 + ?))))))).
+step(add(rule(513, (X1 * (-X2 + (X3 + (X3 + X2)))) = (X1 * (? + (-? + (X3 + X3))))))).
+step(delete(rule(501, (X1 * (X3 + (X4 + ((X1 * X1) + X2)))) = (X1 + (X1 * (X2 + (X3 + X4))))))).
+step(add(rule(514, ((X1 + (X3 * -X1)) * X1) = (X1 * (X1 + (X1 * -X3)))))).
+step(add(rule(515, (X1 * (X1 * -X2)) = (X2 * (X1 * -X1))))).
+step(add(rule(516, (X1 * (X2 * X2)) = (X2 * (X2 * X1))))).
+step(add(rule(517, (X1 * (X1 * X2)) = (X1 * (X2 * X1))))).
+step(add(rule(518, (X1 * X2) = (X2 * X1)))).
+
+lemma((X1 + 0) = X1).
+lemma((X1 + (-X1 + X2)) = X2).
+lemma(-(-X1) = X1).
+lemma((X1 + (X2 + X3)) = (X2 + (X1 + X3))).
+lemma((X2 + (X1 + -X2)) = X1).
+lemma((X1 * (X1 * (X1 * X2))) = (X1 * X2)).
+lemma((X1 + (X2 + -(X1 + X2))) = 0).
+lemma((X1 * ((X1 * X1) + X2)) = (X1 + (X1 * X2))).
+lemma((X1 * 0) = 0).
+lemma((X1 * (X2 + (X1 * X1))) = (X1 + (X1 * X2))).
+lemma((X2 + -(X1 + X2)) = -X1).
+lemma((X1 + (X2 * (X1 * X1))) = ((X1 + X2) * (X1 * X1))).
+lemma((X2 + -(X2 + X1)) = -X1).
+lemma(-(X1 + -X2) = (X2 + -X1)).
+lemma((X1 + (X1 * (X2 * X1))) = (X1 * ((X1 + X2) * X1))).
+lemma((0 * X1) = 0).
+lemma(((X1 * (X2 * X4)) + (X3 * X4)) = (((X1 * X2) + X3) * X4)).
+lemma((X1 * (X3 + (X2 * X3))) = ((X1 + (X1 * X2)) * X3)).
+lemma(((X1 + (X1 * X2)) * X3) = (X1 * (X3 + (X2 * X3)))).
+lemma(((X1 * X4) + (X2 * (X3 * X4))) = ((X1 + (X2 * X3)) * X4)).
+lemma(-(X1 * X2) = (X1 * -X2)).
+lemma((-X1 * X2) = (X1 * -X2)).
+lemma((X1 * ((X2 + (X1 * X1)) * X3)) = ((X1 + (X1 * X2)) * X3)).
+lemma(((X1 + (X2 * X3)) * (X3 * X3)) = (((X1 * X3) + X2) * X3)).
+lemma((((X3 * X2) + X1) * (X2 * X2)) = (((X1 * X2) + X3) * X2)).
+lemma(((X1 + -X2) * -X3) = ((X2 + -X1) * X3)).
+lemma(((X1 + (X1 * X2)) * (X3 * X4)) = (X1 * ((X3 + (X2 * X3)) * X4))).
+lemma(((X1 * X2) + (X3 * (X2 + X4))) = ((X3 * X4) + ((X1 + X3) * X2))).
+lemma(((X1 + (X1 * (X2 * -X2))) * (X2 * X3)) = 0).
+lemma((X1 * ((X2 + (X1 * (X1 * X3))) * X4)) = (X1 * ((X2 + X3) * X4))).
+lemma(((X1 + (X2 * (X3 * X3))) * (X3 * X4)) = ((X1 + X2) * (X3 * X4))).
+lemma((X1 * (X1 * (X2 * X1))) = (X2 * X1)).
+lemma((X1 * (X2 * (X3 * (X1 * X1)))) = (X1 * (X2 * X3))).
diff --git a/misc/ring_noconn.pl b/misc/ring_noconn.pl
new file mode 100644
--- /dev/null
+++ b/misc/ring_noconn.pl
@@ -0,0 +1,977 @@
+:- module(ring_noconn, [step/1, lemma/1]).
+:- discontiguous(step/1).
+:- discontiguous(lemma/1).
+:- style_check(-singleton).
+step(add(rule(1, (X1 + X2) = (X2 + X1)))).
+step(add(rule(2, ((X1 + X2) + X3) = (X1 + (X2 + X3))))).
+step(add(rule(3, (0 + X1) = X1))).
+step(add(rule(4, (X1 + -X1) = 0))).
+step(add(rule(5, ((X1 * X2) * X3) = (X1 * (X2 * X3))))).
+step(add(rule(6, ((X1 * X2) + (X1 * X3)) = (X1 * (X2 + X3))))).
+step(add(rule(7, ((X1 * X3) + (X2 * X3)) = ((X1 + X2) * X3)))).
+step(add(rule(8, (X1 * (X1 * X1)) = X1))).
+step(add(rule(9, -0 = 0))).
+step(add(rule(10, (X1 + 0) = X1))).
+step(add(rule(11, (X1 + (-X1 + X2)) = X2))).
+step(add(rule(12, -(-X1) = X1))).
+step(add(rule(13, (X1 + (X2 + X3)) = (X3 + (X1 + X2))))).
+step(add(rule(14, (X1 + (X2 + X3)) = (X2 + (X1 + X3))))).
+step(hard((X1 * (X2 + X3)) = (X1 * (X3 + X2)))).
+step(hard(((X1 + X2) * X3) = ((X2 + X1) * X3))).
+step(add(rule(15, ((X1 + X1) * X2) = (X1 * (X2 + X2))))).
+step(add(rule(16, (X2 + (X1 + -X2)) = X1))).
+step(add(rule(17, (0 * (X1 + X1)) = (0 * X1)))).
+step(add(rule(18, (X1 * (X1 * (X1 * X2))) = (X1 * X2)))).
+step(hard((X1 + (X2 + X3)) = (X3 + (X2 + X1)))).
+step(hard((X1 + (X2 + X3)) = (X1 + (X3 + X2)))).
+step(add(rule(19, (X1 + (X2 + -(X1 + X2))) = 0))).
+step(add(rule(20, (X1 + -(-X2 + X1)) = X2))).
+step(add(rule(21, (X1 * ((X1 * X1) + X2)) = (X1 + (X1 * X2))))).
+step(add(rule(22, (X1 + (X1 * 0)) = X1))).
+step(add(rule(23, (X1 * 0) = 0))).
+step(add(rule(24, (X1 * (X2 + (X1 * X1))) = (X1 + (X1 * X2))))).
+step(add(rule(25, (X2 + -(X1 + X2)) = -X1))).
+step(add(rule(26, ((X1 + X1) * (X1 * X1)) = (X1 + X1)))).
+step(hard(0 = (X1 + (X2 + -(X2 + X1))))).
+step(add(rule(27, (X2 + -(X2 + -X1)) = X1))).
+step(add(rule(28, -(-X1 + -X2) = (X2 + X1)))).
+step(add(rule(29, (X1 * (0 * X2)) = (0 * X2)))).
+step(add(rule(30, (X1 + (X2 * (X1 * X1))) = ((X1 + X2) * (X1 * X1))))).
+step(add(rule(31, (X2 + -(X2 + X1)) = -X1))).
+step(hard((-X1 + (X2 + (X3 + X1))) = (X3 + X2))).
+step(add(rule(32, (X3 + (X2 + (-X3 + X1))) = (X1 + X2)))).
+step(add(rule(33, (X3 + (X1 + (X2 + -X3))) = (X1 + X2)))).
+step(add(rule(34, -(X1 + -X2) = (X2 + -X1)))).
+step(add(rule(35, (-X1 + -X2) = -(X2 + X1)))).
+step(add(rule(36, -(-X2 + X1) = (-X1 + X2)))).
+step(hard(-(X1 + X2) = -(X2 + X1))).
+step(add(rule(37, (X1 + (X1 * -(X1 * X1))) = 0))).
+step(add(rule(38, (-X1 * -(-X1 * -X1)) = X1))).
+step(add(rule(39, (-X1 * (-X1 * X1)) = X1))).
+step(add(rule(40, (X1 * -(X1 * X1)) = -X1))).
+step(hard((X1 + (X2 + (X3 + X4))) = (X2 + (X3 + (X4 + X1))))).
+step(hard((X1 + (X2 + (X3 + X4))) = (X3 + (X1 + (X2 + X4))))).
+step(hard((X1 + (X2 + (X3 + X4))) = (X3 + (X2 + (X4 + X1))))).
+step(hard((X1 + (X2 + (X3 + X4))) = (X3 + (X4 + (X1 + X2))))).
+step(hard((X1 + (X2 + (X3 + X4))) = (X4 + (X3 + (X1 + X2))))).
+step(hard((X1 + (X2 + (X3 + X4))) = (X4 + (X2 + (X3 + X1))))).
+step(hard((X1 + (X2 + (X3 + X4))) = (X2 + (X4 + (X1 + X3))))).
+step(add(rule(41, ((X1 + X1) * (X2 * X3)) = (X1 * ((X2 + X2) * X3))))).
+step(add(rule(42, (X1 * (X1 * (X1 + X1))) = (X1 + X1)))).
+step(add(rule(43, (X1 * (X2 * (X3 + X3))) = (X1 * ((X2 + X2) * X3))))).
+step(add(rule(44, (X1 * (X2 * (X3 + X3))) = ((X1 + X1) * (X2 * X3))))).
+step(add(rule(45, (X1 + (X1 * (X1 * X2))) = (X1 * (X1 * (X1 + X2)))))).
+step(add(rule(46, (X1 + (X1 * (X2 * X1))) = (X1 * ((X1 + X2) * X1))))).
+step(add(rule(47, (X1 + (0 * X1)) = X1))).
+step(add(rule(48, (0 * X1) = 0))).
+step(hard((X1 * (X1 * (X1 + X2))) = (X1 * (X1 * (X2 + X1))))).
+step(hard((X1 * ((X1 + X2) * X1)) = (X1 * ((X2 + X1) * X1)))).
+step(add(rule(49, (X2 + (X3 + (-(X2 + X3) + X1))) = X1))).
+step(hard((X1 + (X2 + (-(X2 + X1) + X3))) = X3)).
+step(add(rule(50, (X1 * (X1 * -X1)) = -X1))).
+step(hard((X1 + X2) = (-X3 + (X2 + (X3 + X1))))).
+step(hard((X1 + X2) = (-X3 + (X1 + (X2 + X3))))).
+step(hard((X1 + X2) = (-X3 + (X2 + (X1 + X3))))).
+step(add(rule(51, ((X1 * X2) + ((X1 * X3) + X4)) = ((X1 * (X2 + X3)) + X4)))).
+step(hard(((X1 * (X2 + X3)) + X4) = ((X1 * (X3 + X2)) + X4))).
+step(add(rule(52, ((X1 * X2) + ((X3 * X2) + X4)) = (((X1 + X3) * X2) + X4)))).
+step(hard((((X1 + X2) * X3) + X4) = (((X2 + X1) * X3) + X4))).
+step(add(rule(53, (((X1 + X1) * X2) + X3) = ((X1 * (X2 + X2)) + X3)))).
+step(add(rule(54, ((X1 * (X2 * X4)) + (X3 * X4)) = (((X1 * X2) + X3) * X4)))).
+step(add(rule(55, (((X1 * X1) + X2) * X1) = (X1 + (X2 * X1))))).
+step(add(rule(56, (X1 + (-(X1 * X1) * X1)) = 0))).
+step(add(rule(57, (-(X1 * X1) * X1) = -X1))).
+step(add(rule(58, ((X1 + (X1 * X2)) * X3) = (X1 * (X3 + (X2 * X3)))))).
+step(add(rule(59, ((X2 + (X1 * X1)) * X1) = (X1 + (X2 * X1))))).
+step(add(rule(60, ((X1 * X4) + (X2 * (X3 * X4))) = ((X1 + (X2 * X3)) * X4)))).
+step(add(rule(61, (X1 * (X2 * (X1 * (X2 * (X1 * X2))))) = (X1 * X2)))).
+step(add(rule(62, (X3 + (X2 + -(X3 + X1))) = (-X1 + X2)))).
+step(add(rule(63, (X3 + (-(X3 + X2) + X1)) = (X1 + -X2)))).
+step(add(rule(64, (X1 * ((X1 * (X1 * X2)) + X3)) = (X1 * (X2 + X3))))).
+step(add(rule(65, (X1 * (X2 + (X1 * (X1 * X3)))) = (X1 * (X2 + X3))))).
+step(add(rule(66, (X1 * (X2 + X2)) = (X1 * (X1 * ((X1 + X1) * X2)))))).
+step(add(rule(67, (X1 * (X1 * (X1 + (X1 * X2)))) = (X1 + (X1 * X2))))).
+step(add(rule(68, -((X1 + X1) * X2) = -(X1 * (X2 + X2))))).
+step(hard((X1 + -(X3 + X2)) = (-(X2 + X3) + X1))).
+step(hard(-(X3 + (X1 + X2)) = -(X1 + (X3 + X2)))).
+step(add(rule(69, (X1 + (X1 * (-(X1 * X1) + X2))) = (X1 * X2)))).
+step(hard((X1 + (X2 + (X3 + X4))) = (X2 + (X4 + (X3 + X1))))).
+step(add(rule(70, (-(X1 * X3) + (X1 * (X2 + X3))) = (X1 * X2)))).
+step(add(rule(71, -(X1 * -X2) = (X1 * X2)))).
+step(add(rule(72, -(X1 * X2) = (X1 * -X2)))).
+step(add(rule(73, (X1 * (X2 * (-X2 * -X2))) = (X1 * X2)))).
+step(add(rule(74, (-X1 * (X1 * -X1)) = X1))).
+step(add(rule(75, (X1 * (-X1 * -X1)) = X1))).
+step(add(rule(76, (-X1 * (X1 * X1)) = -X1))).
+step(add(rule(77, (X1 * (-X1 * X1)) = -X1))).
+step(add(rule(78, ((X2 * -X3) + ((X1 + X2) * X3)) = (X1 * X3)))).
+step(add(rule(79, (-X1 * -X2) = (X1 * X2)))).
+step(add(rule(80, (-X1 * X2) = (X1 * -X2)))).
+step(add(rule(81, ((X1 * (X2 + X2)) + X3) = (X3 + ((X1 + X1) * X2))))).
+step(add(rule(82, (X1 * -(X2 + X2)) = ((X1 + X1) * -X2)))).
+step(add(rule(83, (X1 + ((X2 + X2) * X3)) = (X1 + (X2 * (X3 + X3)))))).
+step(add(rule(84, (((X1 + X1) * X2) + X3) = (X3 + (X1 * (X2 + X2)))))).
+step(add(rule(85, (X2 + (X3 + (X1 + -(X2 + X3)))) = X1))).
+step(add(rule(86, ((X1 + (X1 * X1)) * (X1 * X1)) = (X1 + (X1 * X1))))).
+step(add(rule(87, ((X1 * X2) + (X3 + (X1 * X4))) = (X3 + (X1 * (X4 + X2)))))).
+step(hard((X1 + (X2 * (X3 + X4))) = ((X2 * (X4 + X3)) + X1))).
+step(hard((X1 * (X2 + (X3 + X4))) = (X1 * (X4 + (X2 + X3))))).
+step(hard((X1 + (X2 * (X3 + X4))) = (X1 + (X2 * (X4 + X3))))).
+step(add(rule(88, ((X1 * X2) + (X3 + (X4 * X2))) = (X3 + ((X4 + X1) * X2))))).
+step(hard((X1 + ((X2 + X3) * X4)) = (((X3 + X2) * X4) + X1))).
+step(hard(((X1 + (X3 + X4)) * X2) = ((X4 + (X1 + X3)) * X2))).
+step(hard((X1 + ((X2 + X3) * X4)) = (X1 + ((X3 + X2) * X4)))).
+step(add(rule(89, ((X1 + X2) * (X3 + X3)) = ((X1 + (X2 + (X1 + X2))) * X3)))).
+step(add(rule(90, ((X1 + (X1 + X2)) * X3) = ((X1 * (X3 + X3)) + (X2 * X3))))).
+step(add(rule(91, ((X1 + (X1 + X1)) * X2) = (X1 * (X2 + (X2 + X2)))))).
+step(add(rule(92, ((X1 + (X2 + X2)) * X3) = ((X1 * X3) + (X2 * (X3 + X3)))))).
+step(add(rule(93, ((X1 + X2) * (X3 + X3)) = ((X2 + (X1 + (X2 + X1))) * X3)))).
+step(add(rule(94, ((X1 + X2) * (X3 + X3)) = ((X1 + (X1 + (X2 + X2))) * X3)))).
+step(add(rule(95, ((X1 + X1) * (X2 + X3)) = (X1 * (X2 + (X3 + (X2 + X3))))))).
+step(add(rule(96, (X1 * (X2 + (X2 + X3))) = (((X1 + X1) * X2) + (X1 * X3))))).
+step(add(rule(97, (X1 * (X2 + (X3 + X3))) = ((X1 * X2) + ((X1 + X1) * X3))))).
+step(add(rule(98, ((X1 + X1) * (X2 + X3)) = (X1 * (X3 + (X2 + (X3 + X2))))))).
+step(add(rule(99, ((X1 + X1) * (X2 + X3)) = (X1 * (X2 + (X2 + (X3 + X3))))))).
+step(add(rule(100, (X1 * (((X1 * X1) + X2) * X3)) = ((X1 + (X1 * X2)) * X3)))).
+step(add(rule(101, (X1 * (X3 + ((X1 * X1) + X2))) = (X1 + (X1 * (X2 + X3)))))).
+step(add(rule(102, (X1 * (X2 + (X3 + (X1 * X1)))) = (X1 + (X1 * (X2 + X3)))))).
+step(add(rule(103, (X1 * ((X2 + (X1 * X1)) * X3)) = ((X1 + (X1 * X2)) * X3)))).
+step(add(rule(104, (X1 + (-(X2 + X1) + X3)) = (-X2 + X3)))).
+step(add(rule(105, (X3 + -(X1 + (X2 + X3))) = -(X1 + X2)))).
+step(add(rule(106, (X1 + (X2 + -(X3 + X1))) = (X2 + -X3)))).
+step(add(rule(107, (((X1 * X1) + X2) * (X1 * X3)) = ((X1 + (X2 * X1)) * X3)))).
+step(add(rule(108, ((X1 + (X2 * X3)) * (X3 * X3)) = (((X1 * X3) + X2) * X3)))).
+step(add(rule(109, ((X1 + (X2 * X2)) * (X2 * X3)) = ((X2 + (X1 * X2)) * X3)))).
+step(add(rule(110, (X1 * (X1 * -(X1 + X1))) = -(X1 + X1)))).
+step(add(rule(111, (X1 * (X1 * ((X1 + X1) * X2))) = ((X1 + X1) * X2)))).
+step(add(rule(112, ((X1 + (X1 + X1)) * (X1 * X1)) = (X1 + (X1 + X1))))).
+step(add(rule(113, (-X1 + (X2 + -X3)) = (X2 + -(X1 + X3))))).
+step(hard((X1 * -(X2 + X3)) = (X1 * -(X3 + X2)))).
+step(add(rule(114, ((X1 + (X1 * (X2 * X2))) * X2) = (X1 * (X2 + X2))))).
+step(hard(-(X2 + (X3 + X1)) = -(X1 + (X2 + X3)))).
+step(hard(-(X3 + (X1 + X2)) = -(X3 + (X2 + X1)))).
+step(add(rule(115, (((X1 * (X2 * X2)) + X3) * X2) = ((X1 + X3) * X2)))).
+step(hard((X1 + -(X2 + X3)) = (X1 + -(X3 + X2)))).
+step(add(rule(116, (X1 + (X1 * (X2 + (X1 * -X1)))) = (X1 * X2)))).
+step(add(rule(117, ((X1 * -X3) + ((X1 + X2) * X3)) = (X2 * X3)))).
+step(add(rule(118, (X1 + (((X1 * -X1) + X2) * X1)) = (X2 * X1)))).
+step(add(rule(119, (X1 + ((X2 + (X1 * -X1)) * X1)) = (X2 * X1)))).
+step(add(rule(120, (X1 + ((-X2 + (X1 * X1)) * -X1)) = (X2 * X1)))).
+step(interreduce).
+step(delete(rule(13, (X1 + (X2 + X3)) = (X3 + (X1 + X2))))).
+step(delete(rule(17, (0 * (X1 + X1)) = (0 * X1)))).
+step(delete(rule(19, (X1 + (X2 + -(X1 + X2))) = 0))).
+step(delete(rule(20, (X1 + -(-X2 + X1)) = X2))).
+step(delete(rule(22, (X1 + (X1 * 0)) = X1))).
+step(delete(rule(26, ((X1 + X1) * (X1 * X1)) = (X1 + X1)))).
+step(delete(rule(27, (X2 + -(X2 + -X1)) = X1))).
+step(delete(rule(28, -(-X1 + -X2) = (X2 + X1)))).
+step(delete(rule(29, (X1 * (0 * X2)) = (0 * X2)))).
+step(delete(rule(37, (X1 + (X1 * -(X1 * X1))) = 0))).
+step(delete(rule(38, (-X1 * -(-X1 * -X1)) = X1))).
+step(delete(rule(39, (-X1 * (-X1 * X1)) = X1))).
+step(delete(rule(40, (X1 * -(X1 * X1)) = -X1))).
+step(delete(rule(47, (X1 + (0 * X1)) = X1))).
+step(delete(rule(49, (X2 + (X3 + (-(X2 + X3) + X1))) = X1))).
+step(delete(rule(56, (X1 + (-(X1 * X1) * X1)) = 0))).
+step(delete(rule(57, (-(X1 * X1) * X1) = -X1))).
+step(delete(rule(66, (X1 * (X2 + X2)) = (X1 * (X1 * ((X1 + X1) * X2)))))).
+step(delete(rule(68, -((X1 + X1) * X2) = -(X1 * (X2 + X2))))).
+step(delete(rule(69, (X1 + (X1 * (-(X1 * X1) + X2))) = (X1 * X2)))).
+step(add(rule(121, (X1 + (X1 * ((X1 * -X1) + X2))) = (X1 * X2)))).
+step(delete(rule(70, (-(X1 * X3) + (X1 * (X2 + X3))) = (X1 * X2)))).
+step(delete(rule(71, -(X1 * -X2) = (X1 * X2)))).
+step(delete(rule(73, (X1 * (X2 * (-X2 * -X2))) = (X1 * X2)))).
+step(delete(rule(74, (-X1 * (X1 * -X1)) = X1))).
+step(delete(rule(75, (X1 * (-X1 * -X1)) = X1))).
+step(delete(rule(76, (-X1 * (X1 * X1)) = -X1))).
+step(delete(rule(77, (X1 * (-X1 * X1)) = -X1))).
+step(delete(rule(79, (-X1 * -X2) = (X1 * X2)))).
+step(delete(rule(85, (X2 + (X3 + (X1 + -(X2 + X3)))) = X1))).
+step(delete(rule(86, ((X1 + (X1 * X1)) * (X1 * X1)) = (X1 + (X1 * X1))))).
+step(delete(rule(89, ((X1 + X2) * (X3 + X3)) = ((X1 + (X2 + (X1 + X2))) * X3)))).
+step(delete(rule(93, ((X1 + X2) * (X3 + X3)) = ((X2 + (X1 + (X2 + X1))) * X3)))).
+step(delete(rule(95, ((X1 + X1) * (X2 + X3)) = (X1 * (X2 + (X3 + (X2 + X3))))))).
+step(delete(rule(98, ((X1 + X1) * (X2 + X3)) = (X1 * (X3 + (X2 + (X3 + X2))))))).
+step(add(rule(122, ((X1 + (X1 * (X2 * -X2))) * X2) = 0))).
+step(add(rule(123, ((X3 * X2) + ((X1 + X3) * -X2)) = (X1 * -X2)))).
+step(add(rule(124, ((X1 + (X1 + (X1 + X1))) * X2) = (X1 * (X2 + (X2 + (X2 + X2))))))).
+step(add(rule(125, ((X1 * X3) + (X2 * (X1 * (X1 * X3)))) = ((X1 + X2) * (X1 * (X1 * X3)))))).
+step(add(rule(126, (X1 * ((X1 + X1) * ((X1 + X1) * (X2 + X2)))) = ((X1 + X1) * X2)))).
+step(add(rule(127, (((X1 + X2) * (X1 * X1)) + X3) = (X1 + ((X2 * (X1 * X1)) + X3))))).
+step(add(rule(128, (X1 + (X2 * (X3 * (X1 * X1)))) = ((X1 + (X2 * X3)) * (X1 * X1))))).
+step(add(rule(129, (X1 + (X2 + (X3 * (X1 * X1)))) = (X2 + ((X1 + X3) * (X1 * X1)))))).
+step(add(rule(130, (X1 * (X1 * (X1 + (X1 + X1)))) = (X1 + (X1 + X1))))).
+step(add(rule(131, ((X1 + (X2 + X2)) * (X1 * X1)) = (X1 + (X2 * (X1 * (X1 + X1))))))).
+step(add(rule(132, ((X1 * (X2 + X3)) + (X4 * X3)) = ((X1 * X2) + ((X1 + X4) * X3))))).
+step(add(rule(133, ((X1 * X2) + ((X1 + X3) * -X2)) = (X3 * -X2)))).
+step(add(rule(134, (X1 + (X1 * ((X1 * X2) + X3))) = (X1 * ((X1 * (X1 + X2)) + X3))))).
+step(add(rule(135, (((X1 + X2) * X3) + (X2 * X4)) = ((X1 * X3) + (X2 * (X3 + X4)))))).
+step(add(rule(136, (((X1 + X2) * (X2 * X2)) + X3) = (X2 + ((X1 * (X2 * X2)) + X3))))).
+step(add(rule(137, (X1 + (X1 * ((X2 * X1) + X3))) = (X1 * (((X1 + X2) * X1) + X3))))).
+step(add(rule(138, (((X1 * X2) + X3) * (X2 * X2)) = ((X1 + (X3 * X2)) * X2)))).
+step(add(rule(139, ((X1 + (X2 * (X3 * X3))) * X3) = ((X1 + X2) * X3)))).
+step(add(rule(140, (X1 + (X1 * (X2 * (X3 * X1)))) = (X1 * (((X2 * X3) + X1) * X1))))).
+step(add(rule(141, ((X1 * -X3) + (X2 * X3)) = ((-X1 + X2) * X3)))).
+step(hard(((-X1 + (X2 + X1)) * X3) = (X2 * X3))).
+step(hard((X1 * X2) = ((-X3 + (X1 + X3)) * X2))).
+step(add(rule(142, (((X1 * -X1) + X2) * -X1) = (X1 + (X2 * -X1))))).
+step(add(rule(143, ((X1 + (X2 * -X2)) * -X2) = (X2 + (X1 * -X2))))).
+step(add(rule(144, (((X1 * -X1) + X2) * X1) = (-X1 + (X2 * X1))))).
+step(add(rule(145, (-X1 + (-X1 + X2)) = (-(X1 + X1) + X2)))).
+step(add(rule(146, (X1 * -((X1 * -X1) + X2)) = (X1 + (X1 * -X2))))).
+step(add(rule(147, (X1 * ((X1 * -X1) + X2)) = (-X1 + (X1 * X2))))).
+step(add(rule(148, (X3 + -(X1 + (X3 + X2))) = -(X1 + X2)))).
+step(hard(X1 = (-X3 + (X1 + X3)))).
+step(add(rule(149, ((X2 + ((X1 * X1) + X3)) * X1) = (X1 + ((X2 + X3) * X1))))).
+step(add(rule(150, (X1 * (X1 * ((X1 * X2) + X3))) = (X1 * (X2 + (X1 * X3)))))).
+step(add(rule(151, (X1 * (X1 * (X2 + (X1 * X3)))) = (X1 * ((X1 * X2) + X3))))).
+step(hard(((X1 * (X2 + X2)) + (X3 * X2)) = ((X1 + (X3 + X1)) * X2))).
+step(add(rule(152, ((X1 + (X1 + X2)) * X3) = ((X2 * X3) + (X1 * (X3 + X3)))))).
+step(hard(((X1 * X2) + (X3 * (X2 + X2))) = ((X3 + (X1 + X3)) * X2))).
+step(hard(((X1 + (X2 + X2)) * X3) = ((X2 * (X3 + X3)) + (X1 * X3)))).
+step(hard(((X1 + (X1 + (X2 + X2))) * X3) = ((X2 + X1) * (X3 + X3)))).
+step(hard(((X1 + X2) * (X3 + X3)) = ((X1 + (X2 + (X2 + X1))) * X3))).
+step(hard(((X1 + X2) * (X3 + X3)) = ((X1 + (X2 + (X1 + X2))) * X3))).
+step(hard((((X1 + X1) * X2) + (X1 * X3)) = (X1 * (X2 + (X3 + X2))))).
+step(add(rule(153, (X1 * (X2 + (X2 + X3))) = ((X1 * X3) + ((X1 + X1) * X2))))).
+step(hard(((X1 * X2) + ((X1 + X1) * X3)) = (X1 * (X3 + (X2 + X3))))).
+step(hard((X1 * (X2 + (X3 + X3))) = (((X1 + X1) * X3) + (X1 * X2)))).
+step(hard((X1 * (X2 + (X2 + (X3 + X3)))) = ((X1 + X1) * (X3 + X2)))).
+step(hard(((X1 + X1) * (X2 + X3)) = (X1 * (X2 + (X3 + (X3 + X2)))))).
+step(hard(((X1 + X1) * (X2 + X3)) = (X1 * (X2 + (X3 + (X2 + X3)))))).
+step(add(rule(154, (X1 * ((X1 + X1) * (X1 + (X1 + (X1 + X1))))) = (X1 + X1)))).
+step(add(rule(155, (X1 * ((X1 * (X1 + X1)) + X2)) = (X1 + (X1 + (X1 * X2)))))).
+step(add(rule(156, (X4 + (X2 + (X3 + (-X4 + X1)))) = (X1 + (X2 + X3))))).
+step(hard((X1 + (X2 + X3)) = (X2 + (X3 + X1)))).
+step(hard((X1 + (-X2 + (X3 + X2))) = (X1 + X3))).
+step(hard((-X1 + (X2 + (X1 + X3))) = (X2 + X3))).
+step(hard((-(X1 + X2) + (X3 + X1)) = (X3 + -X2))).
+step(hard((X4 + (X5 + (X2 + X3))) = (X4 + (X2 + (X3 + X5))))).
+step(hard((-(X1 + X2) + (X3 + X2)) = (-X1 + X3))).
+step(add(rule(157, -(X1 + (-X2 + X3)) = (X2 + -(X3 + X1))))).
+step(hard(-X1 = (-X2 + (-X1 + X2)))).
+step(add(rule(158, (X4 + (X1 + (X2 + (X3 + -X4)))) = (X1 + (X2 + X3))))).
+step(add(rule(159, -(X1 + (X2 + -X3)) = (X3 + -(X1 + X2))))).
+step(add(rule(160, (-X1 + (-X2 + X3)) = (-(X2 + X1) + X3)))).
+step(add(rule(161, -(X3 + (X1 * -X2)) = ((X1 * X2) + -X3)))).
+step(add(rule(162, ((X2 * -X3) + -X1) = -(X1 + (X2 * X3))))).
+step(add(rule(163, (-X3 + (X1 * -X2)) = -((X1 * X2) + X3)))).
+step(add(rule(164, -((X2 * -X3) + X1) = (-X1 + (X2 * X3))))).
+step(add(rule(165, ((X1 + -X2) * -X3) = ((X2 + -X1) * X3)))).
+step(add(rule(166, ((-X1 + X2) * -X3) = ((-X2 + X1) * X3)))).
+step(hard((X1 + (X1 * (-X2 + (X3 + X2)))) = (X1 + (X1 * X3)))).
+step(interreduce).
+step(delete(rule(67, (X1 * (X1 * (X1 + (X1 * X2)))) = (X1 + (X1 * X2))))).
+step(delete(rule(78, ((X2 * -X3) + ((X1 + X2) * X3)) = (X1 * X3)))).
+step(delete(rule(114, ((X1 + (X1 * (X2 * X2))) * X2) = (X1 * (X2 + X2))))).
+step(delete(rule(117, ((X1 * -X3) + ((X1 + X2) * X3)) = (X2 * X3)))).
+step(delete(rule(118, (X1 + (((X1 * -X1) + X2) * X1)) = (X2 * X1)))).
+step(delete(rule(120, (X1 + ((-X2 + (X1 * X1)) * -X1)) = (X2 * X1)))).
+step(delete(rule(121, (X1 + (X1 * ((X1 * -X1) + X2))) = (X1 * X2)))).
+step(delete(rule(145, (-X1 + (-X1 + X2)) = (-(X1 + X1) + X2)))).
+step(delete(rule(146, (X1 * -((X1 * -X1) + X2)) = (X1 + (X1 * -X2))))).
+step(add(rule(167, ((X1 + X1) * (X1 + (X1 + (X1 + X1)))) = (X1 * (X1 + X1))))).
+step(hard((-(X1 + X2) + X3) = (-(X2 + X1) + X3))).
+step(add(rule(168, ((X1 * (X2 + X2)) + ((X1 + X1) * -X2)) = 0))).
+step(add(rule(169, (((X1 + X1) * X2) + (X1 * -(X2 + X2))) = 0))).
+step(add(rule(170, ((X1 * X3) + (X2 * -X3)) = ((-X2 + X1) * X3)))).
+step(add(rule(171, ((X1 + (X1 * (X2 * -X2))) * -X2) = 0))).
+step(add(rule(172, ((X1 + (X1 * (X2 * -X2))) * (X2 * -X2)) = 0))).
+step(hard((X1 + (-X3 + (X2 + X3))) = (X2 + X1))).
+step(hard((X1 * X2) = ((-X4 + (X1 + X4)) * X2))).
+step(add(rule(173, ((X1 * (X2 + X2)) + ((X1 + X1) * X3)) = ((X1 + X1) * (X2 + X3))))).
+step(add(rule(174, (((X1 + X1) * X2) + (X1 * (X3 + X3))) = ((X1 + X1) * (X2 + X3))))).
+step(add(rule(175, (X1 + (X1 + ((X1 + X1) * X2))) = ((X1 + X1) * (X2 + (X1 * X1)))))).
+step(add(rule(176, (X1 * ((X1 + X1) * (X1 + X1))) = (X1 + (X1 + (X1 + X1)))))).
+step(add(rule(177, (((X1 + X1) * X3) + (X2 * (X3 + X3))) = ((X1 + X2) * (X3 + X3))))).
+step(add(rule(178, ((X1 * (X3 + X3)) + ((X2 + X2) * X3)) = ((X1 + X2) * (X3 + X3))))).
+step(add(rule(179, (X1 + (X1 * -(X2 + (X1 * X1)))) = (X1 * -X2)))).
+step(add(rule(180, (X1 + ((X2 + (X1 * X1)) * -X1)) = (X2 * -X1)))).
+step(add(rule(181, (X2 + (X3 + (-X1 + X4))) = (X2 + (X4 + (-X1 + X3)))))).
+step(hard((X1 + (X2 + (X3 + X4))) = (X1 + (X4 + (X3 + X2))))).
+step(add(rule(182, (((X1 + X1) * -X2) + X3) = ((X1 * -(X2 + X2)) + X3)))).
+step(add(rule(183, (X1 + ((X2 + X2) * -X3)) = (X1 + (X2 * -(X3 + X3)))))).
+step(add(rule(184, (X1 + ((X2 + X2) * -X3)) = ((X2 * -(X3 + X3)) + X1)))).
+step(add(rule(185, (X3 * ((X2 + X2) * -X4)) = (X3 * (X2 * -(X4 + X4)))))).
+step(add(rule(186, (X1 * (X4 * -(X3 + X3))) = ((X1 + X1) * (X4 * -X3))))).
+step(add(rule(187, (X2 + (((X2 * X2) + X1) * -X2)) = (X1 * -X2)))).
+step(add(rule(188, ((X1 + (X1 + X1)) * -X2) = (X1 * -(X2 + (X2 + X2)))))).
+step(hard((-(X1 + X2) + (X3 + X4)) = (X3 + (X4 + -(X2 + X1))))).
+step(add(rule(189, (X1 + (X2 * -(X3 + X3))) = (((X2 + X2) * -X3) + X1)))).
+step(add(rule(190, (X1 * (X2 * ((X3 + X3) * X4))) = ((X1 + X1) * (X2 * (X3 * X4)))))).
+step(add(rule(191, (X1 * (X2 * ((X3 + X3) * X4))) = (X1 * ((X2 + X2) * (X3 * X4)))))).
+step(add(rule(192, ((X1 + X1) * (X2 + (X2 + (X2 + X2)))) = (X1 * (X2 + X2))))).
+step(add(rule(193, (X1 * (X2 * ((X3 + X3) * X4))) = (X1 * (X2 * (X3 * (X4 + X4))))))).
+step(add(rule(194, (X1 * ((X2 * (X3 + X3)) + X4)) = (X1 * (((X2 + X2) * X3) + X4))))).
+step(add(rule(195, (X1 * ((X2 + X2) * (X3 * X4))) = (X1 * (X2 * (X3 * (X4 + X4))))))).
+step(add(rule(196, (X1 * (X2 + (X3 * (X4 + X4)))) = (X1 * (X2 + ((X3 + X3) * X4)))))).
+step(add(rule(197, ((X1 + X1) * (X2 * (X3 * X4))) = (X1 * (X2 * (X3 * (X4 + X4))))))).
+step(interreduce).
+step(delete(rule(123, ((X3 * X2) + ((X1 + X3) * -X2)) = (X1 * -X2)))).
+step(delete(rule(133, ((X1 * X2) + ((X1 + X3) * -X2)) = (X3 * -X2)))).
+step(delete(rule(154, (X1 * ((X1 + X1) * (X1 + (X1 + (X1 + X1))))) = (X1 + X1)))).
+step(delete(rule(167, ((X1 + X1) * (X1 + (X1 + (X1 + X1)))) = (X1 * (X1 + X1))))).
+step(delete(rule(168, ((X1 * (X2 + X2)) + ((X1 + X1) * -X2)) = 0))).
+step(add(rule(198, ((X1 * (X1 * (X1 + X2))) + X3) = (X1 + ((X1 * (X1 * X2)) + X3))))).
+step(add(rule(199, (X1 + (X2 + (X1 * (X1 * X3)))) = (X2 + (X1 * (X1 * (X1 + X3))))))).
+step(add(rule(200, (X1 * (X1 * (X1 + (X2 + X2)))) = (X1 + (X1 * ((X1 + X1) * X2)))))).
+step(add(rule(201, ((X1 * ((X1 + X2) * X1)) + X3) = (X1 + ((X1 * (X2 * X1)) + X3))))).
+step(add(rule(202, (X1 + (X2 + (X1 * (X3 * X1)))) = (X2 + (X1 * ((X1 + X3) * X1)))))).
+step(add(rule(203, (X1 * ((X1 + (X2 + X2)) * X1)) = (X1 + (X1 * (X2 * (X1 + X1))))))).
+step(add(rule(204, ((X2 * -X3) + (((X1 + X2) * X3) + X4)) = ((X1 * X3) + X4)))).
+step(hard(((X1 + X3) * X2) = ((-X4 + (X1 + (X4 + X3))) * X2))).
+step(hard(((X1 * X2) + X3) = (((-X4 + (X1 + X4)) * X2) + X3))).
+step(hard(((-X3 + X1) * X2) = ((-(X3 + X4) + (X1 + X4)) * X2))).
+step(add(rule(205, ((X1 * (X2 * (X3 + X3))) + X4) = ((X1 * ((X2 + X2) * X3)) + X4)))).
+step(add(rule(206, ((X1 * (X2 * (X3 + X3))) + X4) = (((X1 + X1) * (X2 * X3)) + X4)))).
+step(add(rule(207, ((X1 * (X2 + X2)) + (X3 + X4)) = (X3 + (((X1 + X1) * X2) + X4))))).
+step(add(rule(208, (((X1 + X1) * X2) + (X3 + X4)) = (X3 + ((X1 * (X2 + X2)) + X4))))).
+step(add(rule(209, (X1 + (X1 * ((X2 + X2) * X3))) = (X1 + (X1 * (X2 * (X3 + X3))))))).
+step(add(rule(210, (((X1 + X1) * (X2 * X3)) + X4) = ((X1 * ((X2 + X2) * X3)) + X4)))).
+step(add(rule(211, ((((X1 + X1) * X2) + X3) * X4) = (((X1 * (X2 + X2)) + X3) * X4)))).
+step(add(rule(212, (X1 + ((X1 + (X2 * X1)) * X1)) = ((X1 + ((X1 + X2) * X1)) * X1)))).
+step(simplify_queue).
+step(interreduce).
+step(hard((X1 + X2) = (X2 + (-X4 + (X1 + X4))))).
+step(hard((X1 + ((X1 * (X3 + X2)) + X4)) = (X1 + ((X1 * (X2 + X3)) + X4)))).
+step(hard((X4 + (X1 * (-X3 + (X2 + X3)))) = ((X1 * X2) + X4))).
+step(add(rule(213, (X1 + (X1 * (X1 + (X1 * X2)))) = (X1 * (X1 + (X1 * (X2 + X1))))))).
+step(hard((X1 * (X1 + (X1 * (X1 + X2)))) = (X1 * (X1 + (X1 * (X2 + X1)))))).
+step(add(rule(214, ((X1 + (X1 * X2)) * (X1 * X1)) = (X1 * ((X1 + (X2 * X1)) * X1))))).
+step(add(rule(215, (X1 + (X1 * (X1 + (X2 * X1)))) = (X1 * (X1 + ((X1 + X2) * X1)))))).
+step(add(rule(216, (X1 + (((X1 * X2) + X3) * X1)) = (((X1 * (X1 + X2)) + X3) * X1)))).
+step(add(rule(217, (X1 + (((X2 * X1) + X3) * X1)) = ((((X1 + X2) * X1) + X3) * X1)))).
+step(hard(((-X2 + (X1 + X2)) * (X1 * X1)) = X1)).
+step(add(rule(218, ((X1 + (X1 * X2)) * (X3 * X4)) = (X1 * ((X3 + (X2 * X3)) * X4))))).
+step(add(rule(219, (X1 * (X2 * (X3 + (X4 * X3)))) = (X1 * ((X2 + (X2 * X4)) * X3))))).
+step(add(rule(220, (X1 * (X2 * (X3 + (X2 * X3)))) = ((X1 + (X1 * X2)) * (X2 * X3))))).
+step(add(rule(221, (X1 * (X2 + ((X3 + X3) * X2))) = ((X1 + ((X1 + X1) * X3)) * X2)))).
+step(add(rule(222, (X1 * (X2 + (X1 * (X3 * X2)))) = (X1 * (X1 * ((X1 + X3) * X2)))))).
+step(add(rule(223, (X1 * (X2 + (X3 * (X1 * X2)))) = (X1 * ((X1 + X3) * (X1 * X2)))))).
+step(add(rule(224, ((X1 + (X1 * (X2 * X3))) * X4) = (X1 * (X4 + (X2 * (X3 * X4))))))).
+step(add(rule(225, ((X1 + (X1 * (X2 + X2))) * X3) = (X1 * (X3 + (X2 * (X3 + X3))))))).
+step(add(rule(226, ((X1 + ((X2 + X2) * X3)) * X4) = ((X1 + (X2 * (X3 + X3))) * X4)))).
+step(add(rule(227, (X1 * (X3 + (X2 * (X1 * X3)))) = (X1 * ((X2 + X1) * (X1 * X3)))))).
+step(add(rule(228, (X1 * -(X2 + (X1 * (X1 * -X2)))) = 0))).
+step(add(rule(229, (X1 * -((X1 * X1) + X2)) = -(X1 + (X1 * X2))))).
+step(add(rule(230, (X1 * -(X2 + (X1 * X1))) = -(X1 + (X1 * X2))))).
+step(add(rule(231, (((X1 * X1) + X2) * -X1) = -(X1 + (X2 * X1))))).
+step(interreduce).
+step(delete(rule(179, (X1 + (X1 * -(X2 + (X1 * X1)))) = (X1 * -X2)))).
+step(delete(rule(187, (X2 + (((X2 * X2) + X1) * -X2)) = (X1 * -X2)))).
+step(delete(rule(214, ((X1 + (X1 * X2)) * (X1 * X1)) = (X1 * ((X1 + (X2 * X1)) * X1))))).
+step(add(rule(232, ((X1 + (X2 * X2)) * -X2) = -(X2 + (X1 * X2))))).
+step(add(rule(233, ((X1 * X2) + (X3 * (X2 + X4))) = ((X3 * X4) + ((X1 + X3) * X2))))).
+step(hard((X1 + (X2 + (X2 * (X4 + X3)))) = (X2 + (X1 + (X2 * (X3 + X4)))))).
+step(add(rule(234, (X1 + (X1 * (X2 + (X1 * X3)))) = (X1 * (X2 + (X1 * (X3 + X1))))))).
+step(hard((X4 + (X1 * (X5 + (X2 + X3)))) = (X4 + (X1 * (X5 + (X3 + X2)))))).
+step(add(rule(235, ((X1 * X2) + (X3 * (X4 + X2))) = (((X3 + X1) * X2) + (X3 * X4))))).
+step(hard((X1 * (-X2 + (X3 + X2))) = (X1 * X3))).
+step(add(rule(236, (X1 + ((X2 + (X1 * X3)) * X1)) = ((X2 + (X1 * (X3 + X1))) * X1)))).
+step(add(rule(237, ((X1 * X2) + ((X1 + X3) * X4)) = ((X3 * X4) + (X1 * (X2 + X4)))))).
+step(add(rule(238, (X1 + ((X2 + X3) * (X3 * X3))) = (X3 + (X1 + (X2 * (X3 * X3))))))).
+step(add(rule(239, (X1 + ((X2 + X3) * (X2 * X2))) = ((X3 * (X2 * X2)) + (X1 + X2))))).
+step(add(rule(240, (X1 + (X1 * (X2 + (X3 * X1)))) = (X1 * (X2 + ((X3 + X1) * X1)))))).
+step(add(rule(241, ((X1 * X2) + ((X3 + X1) * X4)) = ((X1 * (X4 + X2)) + (X3 * X4))))).
+step(hard((X4 + ((X5 + (X1 + X2)) * X3)) = (X4 + ((X5 + (X2 + X1)) * X3)))).
+step(add(rule(242, (X1 + ((X2 + (X3 * X1)) * X1)) = ((X2 + ((X3 + X1) * X1)) * X1)))).
+step(hard(((X1 + (X1 + X2)) * (X2 * X2)) = (X2 + (X1 * (X2 * (X2 + X2)))))).
+step(hard((X1 + (X1 * (X2 * (X1 + X1)))) = (X1 * ((X2 + (X2 + X1)) * X1)))).
+step(hard(((X1 + (X1 + (X2 + X2))) * X3) = ((X1 + (X2 + (X1 + X2))) * X3))).
+step(add(rule(243, (((X1 * (X1 + X1)) + (X2 + X2)) * X1) = (((X1 * X1) + X2) * (X1 + X1))))).
+step(hard((X1 + (X1 * ((X1 + X1) * X2))) = (X1 * (X1 * (X2 + (X2 + X1)))))).
+step(add(rule(244, (X1 * (X3 + (X2 * (X3 + X3)))) = ((X1 + ((X1 + X1) * X2)) * X3)))).
+step(add(rule(245, (X1 * (X2 + (X2 + (X3 * X2)))) = ((X1 + (X1 + (X1 * X3))) * X2)))).
+step(hard((X1 * (X1 * (X2 + (X1 + X1)))) = (X1 * (X1 * (X1 + (X1 + X2)))))).
+step(hard((X1 * (X2 + (X2 + (X3 + X3)))) = (X1 * (X2 + (X3 + (X2 + X3)))))).
+step(add(rule(246, ((X1 + X1) * ((X1 * X1) + X2)) = (X1 + (X1 + (X1 * (X2 + X2))))))).
+step(hard((X1 * (X1 + ((X1 + X2) * X1))) = (X1 * (X1 + ((X2 + X1) * X1))))).
+step(add(rule(247, (X1 * (((X1 * (X1 + X1)) + X2) * X3)) = (X1 * (X3 + (X3 + (X2 * X3))))))).
+step(interreduce).
+step(delete(rule(116, (X1 + (X1 * (X2 + (X1 * -X1)))) = (X1 * X2)))).
+step(delete(rule(119, (X1 + ((X2 + (X1 * -X1)) * X1)) = (X2 * X1)))).
+step(delete(rule(180, (X1 + ((X2 + (X1 * X1)) * -X1)) = (X2 * -X1)))).
+step(delete(rule(212, (X1 + ((X1 + (X2 * X1)) * X1)) = ((X1 + ((X1 + X2) * X1)) * X1)))).
+step(delete(rule(213, (X1 + (X1 * (X1 + (X1 * X2)))) = (X1 * (X1 + (X1 * (X2 + X1))))))).
+step(delete(rule(215, (X1 + (X1 * (X1 + (X2 * X1)))) = (X1 * (X1 + ((X1 + X2) * X1)))))).
+step(add(rule(248, (X1 * (X2 + (X2 + (X1 * (X1 + X1))))) = ((X1 + X1) * ((X1 * X1) + X2))))).
+step(add(rule(249, (X1 + (X1 + (X1 * (X2 + X2)))) = ((X1 + X1) * (X2 + (X1 * X1)))))).
+step(hard((X1 * (X1 * ((X1 + X2) * X3))) = (X1 * (X1 * ((X2 + X1) * X3))))).
+step(hard((X1 * ((X1 + X2) * (X1 * X3))) = (X1 * ((X2 + X1) * (X1 * X3))))).
+step(add(rule(250, ((X1 + ((X1 * X1) + X2)) * (X1 * X1)) = ((X1 + ((X2 + X1) * X1)) * X1)))).
+step(add(rule(251, ((X1 + (X1 * (X2 * X3))) * X3) = (X1 * ((X2 + X3) * (X3 * X3)))))).
+step(hard((X1 * ((X2 + X1) * X2)) = (X1 * ((X1 + X2) * X2)))).
+step(add(rule(252, ((X1 + (X2 + (X1 * X1))) * (X1 * X1)) = ((X1 + ((X2 + X1) * X1)) * X1)))).
+step(add(rule(253, (X1 * ((X1 + (X2 * (X1 * X2))) * (X1 * X2))) = ((X1 + X1) * X2)))).
+step(hard((X1 + ((X2 * (X1 * X1)) + X3)) = (X3 + ((X1 + X2) * (X1 * X1))))).
+step(hard(((X1 + ((X2 + X1) * X1)) * X1) = ((X1 + ((X1 + X2) * X1)) * X1))).
+step(hard(((X1 + (X2 + X3)) * (X1 * X1)) = ((X2 + (X1 + X3)) * (X1 * X1)))).
+step(hard(((X2 + ((X3 + X1) * X1)) * X1) = ((X2 + ((X1 + X3) * X1)) * X1))).
+step(hard((X1 + (X2 * (X1 * (X1 + X1)))) = ((X2 + (X1 + X2)) * (X1 * X1)))).
+step(add(rule(254, ((X1 * X2) + ((X1 + X3) * X4)) = ((X1 * (X4 + X2)) + (X3 * X4))))).
+step(add(rule(255, ((X1 * (X2 + X3)) + (X4 * X3)) = (((X1 + X4) * X3) + (X1 * X2))))).
+step(add(rule(256, ((X1 * (X2 + X3)) + (X4 * X3)) = ((X1 * X2) + ((X4 + X1) * X3))))).
+step(hard((X1 * ((X1 * (X1 + X2)) + X3)) = (X1 * (X3 + (X1 * (X2 + X1)))))).
+step(add(rule(257, ((X1 * X2) + (X3 * (X2 + X4))) = (((X3 + X1) * X2) + (X3 * X4))))).
+step(hard((((X1 + X2) * X3) + (X2 * X4)) = ((X2 * (X3 + X4)) + (X1 * X3)))).
+step(add(rule(258, (((X1 + X2) * X3) + (X2 * X4)) = ((X1 * X3) + (X2 * (X4 + X3)))))).
+step(hard((X1 + ((X2 * (X1 * X1)) + X3)) = (X3 + ((X2 + X1) * (X1 * X1))))).
+step(hard(((((X1 + X2) * X1) + X3) * X1) = ((((X2 + X1) * X1) + X3) * X1))).
+step(hard((X1 * (((X1 + X2) * X1) + X3)) = (X1 * (X3 + ((X2 + X1) * X1))))).
+step(add(rule(259, ((X1 + (X1 * (X2 * X3))) * X3) = (X1 * ((X3 + X2) * (X3 * X3)))))).
+step(add(rule(260, ((X2 + (X1 * -X1)) * X1) = (-X1 + (X2 * X1))))).
+step(add(rule(261, (X1 * (X2 + (X1 * -X1))) = (-X1 + (X1 * X2))))).
+step(add(rule(262, ((X1 + X1) * (X2 + (X2 + X2))) = ((X1 + (X1 + X1)) * (X2 + X2))))).
+step(interreduce).
+step(delete(rule(241, ((X1 * X2) + ((X3 + X1) * X4)) = ((X1 * (X4 + X2)) + (X3 * X4))))).
+step(delete(rule(255, ((X1 * (X2 + X3)) + (X4 * X3)) = (((X1 + X4) * X3) + (X1 * X2))))).
+step(add(rule(263, (X1 + (X1 + (X2 * (X1 + X1)))) = (((X1 * X1) + X2) * (X1 + X1))))).
+step(add(rule(264, (X2 + (X2 + (X1 * (X2 * (X2 + X2))))) = ((X1 + X2) * (X2 * (X2 + X2)))))).
+step(add(rule(265, (X3 + (X4 + (X2 + (-(X3 + X4) + X1)))) = (X1 + X2)))).
+step(hard((X1 + -X2) = (-(X2 + X3) + (X1 + X3)))).
+step(hard((X1 + (X2 + (X3 + X4))) = (X1 + (X2 + (X4 + X3))))).
+step(hard((X3 + (X4 + (X5 + X2))) = (X3 + (X5 + (X4 + X2))))).
+step(hard((X1 + X2) = (X2 + (-(X4 + X5) + (X1 + (X4 + X5)))))).
+step(add(rule(266, (X3 + (X4 + (X1 + (X2 + -(X3 + X4))))) = (X1 + X2)))).
+step(add(rule(267, (X1 * (X2 + (X1 * (X1 + X1)))) = (X1 + (X1 + (X1 * X2)))))).
+step(add(rule(268, ((X2 + (X3 + (X1 * X1))) * X1) = (X1 + ((X2 + X3) * X1))))).
+step(add(rule(269, (X1 * (X2 + ((X1 * (X1 * -X2)) + X3))) = (X1 * X3)))).
+step(hard((X1 * X2) = (X1 * (-X3 + (X2 + X3))))).
+step(add(rule(270, (X1 * (X2 + (X3 + (X1 * (X1 * -X2))))) = (X1 * X3)))).
+step(hard((X1 + -X2) = (-X3 + (X1 + (X3 + -X2))))).
+step(add(rule(271, ((X1 + X1) * (X2 + X2)) = (X1 * ((X1 + X1) * ((X1 + X1) * X2)))))).
+step(add(rule(272, ((X1 + X1) * ((X1 + X1) * (X2 + X2))) = (X1 * ((X1 + X1) * X2))))).
+step(hard((-X2 + X1) = (-(X2 + X3) + (X1 + X3)))).
+step(add(rule(273, (((X1 * (X1 + X1)) + X2) * X1) = (X1 + (X1 + (X2 * X1)))))).
+step(hard(((X1 + (X3 + (X3 + X1))) * X2) = ((X3 + X1) * (X2 + X2)))).
+step(add(rule(274, ((X1 + (X2 * (X2 + X2))) * X2) = (X2 + (X2 + (X1 * X2)))))).
+step(hard((X1 * (X2 + (X3 + (X3 + X2)))) = ((X1 + X1) * (X3 + X2)))).
+step(hard((X1 + (X2 + X3)) = (-X4 + (X2 + (X3 + (X4 + X1)))))).
+step(hard((X1 + (-X2 + (X3 + (X4 + X2)))) = (X1 + (X4 + X3)))).
+step(hard((X1 + (X2 + X3)) = (-X4 + (X1 + (X2 + (X3 + X4)))))).
+step(hard((X1 + (X2 + (-X3 + (X4 + X3)))) = (X1 + (X2 + X4)))).
+step(hard(((X1 * X2) + X3) = (((-X5 + (X1 + X5)) * X2) + X3))).
+step(hard((X1 + ((-X2 + (X4 + X2)) * X3)) = (X1 + (X4 * X3)))).
+step(hard((X1 + (X3 + (-X2 + (X4 + X2)))) = (X3 + (X4 + X1)))).
+step(hard((X1 * (X2 * X3)) = (X1 * (X2 * (-X4 + (X3 + X4)))))).
+step(hard((X1 * (X2 * X3)) = (X1 * ((-X4 + (X2 + X4)) * X3)))).
+step(add(rule(275, (X1 * (X2 + (X1 * (X1 + (X1 * -X2))))) = X1))).
+step(hard(((X1 * -(X2 + X2)) + ((X1 + X1) * X2)) = 0)).
+step(add(rule(276, (X1 * (X2 * (X1 * (X2 * (X1 * (X2 * X3)))))) = (X1 * (X2 * X3))))).
+step(interreduce).
+step(delete(rule(126, (X1 * ((X1 + X1) * ((X1 + X1) * (X2 + X2)))) = ((X1 + X1) * X2)))).
+step(delete(rule(243, (((X1 * (X1 + X1)) + (X2 + X2)) * X1) = (((X1 * X1) + X2) * (X1 + X1))))).
+step(add(rule(277, (X1 + (X1 + ((X2 + X2) * X1))) = (((X1 * X1) + X2) * (X1 + X1))))).
+step(add(rule(278, ((X1 * X2) + (X3 + ((X1 * X4) + X5))) = (X3 + ((X1 * (X2 + X4)) + X5))))).
+step(hard((X1 + (X2 * (X3 + (X4 + X5)))) = (X1 + (X2 * (X4 + (X5 + X3)))))).
+step(hard(((X1 * (X2 + (X3 + X4))) + X5) = ((X1 * (X3 + (X2 + X4))) + X5))).
+step(add(rule(279, ((X1 * (X2 + (X2 + X3))) + X4) = (((X1 + X1) * X2) + ((X1 * X3) + X4))))).
+step(add(rule(280, (X4 + ((X1 * (X2 + X2)) + X5)) = (((X1 + X1) * X2) + (X5 + X4))))).
+step(add(rule(281, ((X1 * (X2 + (X2 + X2))) + X3) = (((X1 + (X1 + X1)) * X2) + X3)))).
+step(add(rule(282, (-? + ((X2 * (X3 + X3)) + ?)) = ((X2 + X2) * X3)))).
+step(add(rule(283, (-X1 + ((X2 * (X3 + X3)) + X1)) = (-? + ((X2 * (X3 + X3)) + ?))))).
+step(add(rule(284, ((X1 * (X2 + (X3 + X3))) + X4) = ((X1 * X2) + (((X1 + X1) * X3) + X4))))).
+step(add(rule(285, (X1 + (((X1 + X1) * X2) + X3)) = (X1 + ((X1 * (X2 + X2)) + X3))))).
+step(add(rule(286, ((X1 * (X2 * X4)) + ((X3 * X4) + X5)) = ((((X1 * X2) + X3) * X4) + X5)))).
+step(add(rule(287, ((-X3 + ((X1 * X2) + X3)) * X4) = (X1 * (X2 * X4))))).
+step(add(rule(288, ((X1 * X3) + ((X2 * (X1 * X3)) + X4)) = (((X1 + (X2 * X1)) * X3) + X4)))).
+step(add(rule(289, (((X1 + (X1 * X2)) * X3) + X4) = ((X1 * (X3 + (X2 * X3))) + X4)))).
+step(add(rule(290, ((X1 + (X1 * X2)) * -X3) = (X1 * -(X3 + (X2 * X3)))))).
+step(hard(((X1 + X1) * X2) = ((-X3 + (X1 + (X1 + X3))) * X2))).
+step(add(rule(291, ((X1 * X4) + ((X2 * (X3 * X4)) + X5)) = (((X1 + (X2 * X3)) * X4) + X5)))).
+step(add(rule(292, ((X1 * X2) + (X3 + ((X4 * X2) + X5))) = (X3 + (((X1 + X4) * X2) + X5))))).
+step(hard((X1 + ((-X3 + (X2 + X3)) * X4)) = ((X2 * X4) + X1))).
+step(hard((X1 + ((X2 + (X3 + X5)) * X4)) = (X1 + ((X3 + (X5 + X2)) * X4)))).
+step(hard((((X1 + (X3 + X4)) * X2) + X5) = (((X3 + (X1 + X4)) * X2) + X5))).
+step(add(rule(293, (X1 + (((X2 + X2) * X3) + X4)) = (X1 + ((X2 * (X3 + X3)) + X4))))).
+step(add(rule(294, (((X1 + (X1 + X2)) * X3) + X4) = ((X1 * (X3 + X3)) + ((X2 * X3) + X4))))).
+step(hard(((-X2 + (X1 + (X1 + X2))) * X3) = (X1 * (X3 + X3)))).
+step(add(rule(295, (((X1 + (X2 + X2)) * X3) + X4) = ((X1 * X3) + ((X2 * (X3 + X3)) + X4))))).
+step(add(rule(296, ((X1 * (X2 * (X3 * X5))) + (X4 * X5)) = (((X1 * (X2 * X3)) + X4) * X5)))).
+step(add(rule(297, ((X1 * (X2 * X5)) + (X3 * (X4 * X5))) = (((X1 * X2) + (X3 * X4)) * X5)))).
+step(add(rule(298, ((X1 * X4) + (X2 * (X3 * (X1 * X4)))) = ((X1 + (X2 * (X3 * X1))) * X4)))).
+step(add(rule(299, ((X1 * (X2 * X3)) + (X4 + (X5 * X3))) = (X4 + (((X1 * X2) + X5) * X3))))).
+step(add(rule(300, ((X1 + ((X3 * X4) + X5)) * X2) = (((X3 * X4) + (X1 + X5)) * X2)))).
+step(hard(((X1 + (X2 + X3)) * X4) = ((X2 + (X1 + X3)) * X4))).
+step(add(rule(301, ((X2 * X4) + (X1 + (X3 * (X2 * X4)))) = (X1 + ((X2 + (X3 * X2)) * X4))))).
+step(hard(((((X1 + X4) * X2) + X5) * X3) = ((((X4 + X1) * X2) + X5) * X3))).
+step(add(rule(302, (X1 + ((X2 + (X2 * X3)) * X4)) = (X1 + (X2 * (X4 + (X3 * X4))))))).
+step(add(rule(303, ((((X1 + X1) * X2) + X3) * X4) = ((X1 * (X2 * (X4 + X4))) + (X3 * X4))))).
+step(add(rule(304, ((X1 + X1) * ((X2 + (X1 * X1)) * X3)) = (X1 * (((X3 * X3) + X2) * (X3 + X3)))))).
+step(add(rule(305, ((X1 + X1) * (-X2 + (X1 * (X1 * X2)))) = 0))).
+step(add(rule(306, (((X1 * (X2 + X2)) + X3) * X4) = ((X1 * (X2 * (X4 + X4))) + (X3 * X4))))).
+step(add(rule(307, (((X1 * X2) + (X3 + X3)) * X4) = ((X1 * (X2 * X4)) + (X3 * (X4 + X4)))))).
+step(interreduce).
+step(delete(rule(125, ((X1 * X3) + (X2 * (X1 * (X1 * X3)))) = ((X1 + X2) * (X1 * (X1 * X3)))))).
+step(delete(rule(282, (-? + ((X2 * (X3 + X3)) + ?)) = ((X2 + X2) * X3)))).
+step(delete(rule(283, (-X1 + ((X2 * (X3 + X3)) + X1)) = (-? + ((X2 * (X3 + X3)) + ?))))).
+step(add(rule(308, (-X1 + ((X2 * (X3 + X3)) + X1)) = (X2 * (X3 + X3))))).
+step(delete(rule(285, (X1 + (((X1 + X1) * X2) + X3)) = (X1 + ((X1 * (X2 + X2)) + X3))))).
+step(delete(rule(288, ((X1 * X3) + ((X2 * (X1 * X3)) + X4)) = (((X1 + (X2 * X1)) * X3) + X4)))).
+step(hard((X1 + X1) = (-X2 + (X1 + (X1 + X2))))).
+step(hard((X1 + X2) = (-X3 + (X1 + (X3 + X2))))).
+step(add(rule(309, ((X1 + X1) * ((X2 + (X1 * X1)) * X3)) = ((X1 + X1) * (X3 + (X2 * X3)))))).
+step(add(rule(310, (((X1 * X2) + X3) * (X2 * (X2 * X4))) = ((X1 + (X3 * X2)) * (X2 * X4))))).
+step(add(rule(311, ((X1 + (X1 * (X2 * -X2))) * (X2 * X3)) = 0))).
+step(add(rule(312, (X1 * (X2 + (X2 * (X1 * -X1)))) = 0))).
+step(hard((X1 * ((-X2 + (X1 + X2)) * X1)) = X1)).
+step(add(rule(313, ((X1 + (X1 * (X2 * -X2))) * (X2 + X2)) = 0))).
+step(add(rule(314, (X1 * ((X2 + (X1 * (X1 * -X2))) * X3)) = 0))).
+step(add(rule(315, ((X1 + (X2 * (X2 * -X1))) * X2) = 0))).
+step(add(rule(316, (X1 * ((X2 + (X2 * (X1 * -X1))) * X3)) = 0))).
+step(add(rule(317, (X1 * -(X2 + (X2 * (X1 * -X1)))) = 0))).
+step(add(rule(318, ((-X1 + (X2 * (X2 * X1))) * X2) = 0))).
+step(add(rule(319, ((X1 * X5) + (X2 * (X3 * (X4 * X5)))) = ((X1 + (X2 * (X3 * X4))) * X5)))).
+step(add(rule(320, ((X1 * X2) + (X3 + (X4 * (X5 * X2)))) = (X3 + ((X1 + (X4 * X5)) * X2))))).
+step(hard(((X4 + ((X5 + X1) * X2)) * X3) = ((X4 + ((X1 + X5) * X2)) * X3))).
+step(hard(((X2 + (X1 * (X3 + X1))) * X1) = ((X2 + (X1 * (X1 + X3))) * X1))).
+step(add(rule(321, ((X1 + (X1 + (X2 * X3))) * X4) = ((X1 * (X4 + X4)) + (X2 * (X3 * X4)))))).
+step(add(rule(322, ((X1 + ((X2 + X2) * X3)) * X4) = ((X1 * X4) + (X2 * (X3 * (X4 + X4))))))).
+step(add(rule(323, (X1 + (X2 * (X3 * (X1 + X1)))) = (X1 + ((X2 + X2) * (X3 * X1)))))).
+step(add(rule(324, ((X1 + (X2 * (X3 + X3))) * X4) = ((X1 * X4) + (X2 * (X3 * (X4 + X4))))))).
+step(add(rule(325, (X1 + (X2 * (X3 * (X1 + X1)))) = (X1 + (X2 * ((X3 + X3) * X1)))))).
+step(add(rule(326, ((X1 + (X2 * X3)) * (X3 * (X3 * X4))) = (((X1 * X3) + X2) * (X3 * X4))))).
+step(add(rule(327, (X1 * ((X2 * (X1 * (X2 * (X1 * X2)))) + X3)) = (X1 * (X2 + X3))))).
+step(add(rule(328, (X1 * (X2 + (X3 * (X1 * (X3 * (X1 * X3)))))) = (X1 * (X2 + X3))))).
+step(add(rule(329, (X1 + (X2 + (-(X1 + X3) + X4))) = (-X3 + (X2 + X4))))).
+step(hard(-(X3 + (X2 + X1)) = -(X1 + (X2 + X3)))).
+step(add(rule(330, (X4 + (X2 + (X3 + -(X4 + X1)))) = (-X1 + (X2 + X3))))).
+step(hard((-(X1 + X2) + (X3 + X1)) = (-X2 + X3))).
+step(add(rule(331, (X4 + (X3 + -(X1 + (X4 + X2)))) = (-(X1 + X2) + X3)))).
+step(hard((X1 + X2) = (-X4 + (X1 + (X4 + X2))))).
+step(add(rule(332, (X4 + (-(X2 + (X4 + X3)) + X1)) = (X1 + -(X2 + X3))))).
+step(hard((X1 + X2) = (-X4 + (X2 + (X4 + X1))))).
+step(add(rule(333, (X2 + ((X2 + X1) * (X2 * -X2))) = (X1 * (X2 * -X2))))).
+step(add(rule(334, (X2 + (X1 * (X2 * -X2))) = ((-X1 + X2) * (X2 * X2))))).
+step(add(rule(335, (X1 + (X1 * (X2 * -X1))) = (X1 * ((-X2 + X1) * X1))))).
+step(add(rule(336, (((X1 * (X2 * (X1 * X2))) + X3) * (X1 * X2)) = ((X1 + (X3 * X1)) * X2)))).
+step(add(rule(337, (X1 * (X2 + (X3 * X2))) = (X1 * (X1 * ((X1 + (X1 * X3)) * X2)))))).
+step(add(rule(338, (X1 * (((X1 * (X1 * X2)) + X3) * X4)) = (X1 * ((X2 + X3) * X4))))).
+step(add(rule(339, (X1 * (X2 + ((X1 * (X1 * X3)) + X4))) = (X1 * (X2 + (X3 + X4)))))).
+step(hard((X1 * (X2 + (X3 + X4))) = (X1 * (X3 + (X2 + X4))))).
+step(add(rule(340, (X1 * (X2 + (X2 + X3))) = (X1 * ((X1 * ((X1 + X1) * X2)) + X3))))).
+step(interreduce).
+step(delete(rule(172, ((X1 + (X1 * (X2 * -X2))) * (X2 * -X2)) = 0))).
+step(delete(rule(269, (X1 * (X2 + ((X1 * (X1 * -X2)) + X3))) = (X1 * X3)))).
+step(delete(rule(298, ((X1 * X4) + (X2 * (X3 * (X1 * X4)))) = ((X1 + (X2 * (X3 * X1))) * X4)))).
+step(delete(rule(301, ((X2 * X4) + (X1 + (X3 * (X2 * X4)))) = (X1 + ((X2 + (X3 * X2)) * X4))))).
+step(delete(rule(333, (X2 + ((X2 + X1) * (X2 * -X2))) = (X1 * (X2 * -X2))))).
+step(add(rule(341, (X1 * ((X1 * (X1 + (X1 * X2))) + X3)) = (X1 + (X1 * (X2 + X3)))))).
+step(add(rule(342, (X1 * (X2 + (X3 + (X1 * (X1 * X4))))) = (X1 * (X2 + (X3 + X4)))))).
+step(hard((X1 * (X2 + (X3 + X4))) = (X1 * (X2 + (X4 + X3))))).
+step(add(rule(343, (X1 * ((X2 + (X1 * (X1 * X3))) * X4)) = (X1 * ((X2 + X3) * X4))))).
+step(hard((X1 * ((X2 + X3) * X4)) = (X1 * ((X3 + X2) * X4)))).
+step(add(rule(344, (X1 * (X2 + (X3 + X3))) = (X1 * (X2 + (X1 * ((X1 + X1) * X3))))))).
+step(add(rule(345, (X1 * (X2 + (X1 * (X1 + (X1 * X3))))) = (X1 + (X1 * (X3 + X2)))))).
+step(add(rule(346, (-X1 + (X2 * (X1 * X1))) = ((-X1 + X2) * (X1 * X1))))).
+step(add(rule(347, (X1 * (X1 * (-X1 + X2))) = (X1 * (X1 * (X2 + -X1)))))).
+step(hard(((X1 * -(X2 + X3)) + X4) = ((X1 * -(X3 + X2)) + X4))).
+step(add(rule(348, ((X1 + (X1 * -X2)) * X3) = (X1 * (X3 + (X2 * -X3)))))).
+step(hard((X1 + (X2 * -(X3 + X4))) = (X1 + (X2 * -(X4 + X3))))).
+step(add(rule(349, (X1 * (X1 * ((X1 + (X1 * X2)) * X3))) = ((X1 + (X1 * X2)) * X3)))).
+step(add(rule(350, -(((X1 + X1) * X2) + X3) = -((X1 * (X2 + X2)) + X3)))).
+step(add(rule(351, -(X1 + ((X2 + X2) * X3)) = -(X1 + (X2 * (X3 + X3)))))).
+step(add(rule(352, -((X1 * (X2 + X2)) + X3) = -(X3 + ((X1 + X1) * X2))))).
+step(add(rule(353, -(((X1 + X1) * X2) + X3) = -(X3 + (X1 * (X2 + X2)))))).
+step(add(rule(354, (((X1 * (X2 * (X3 * X3))) + X4) * X3) = (((X1 * X2) + X4) * X3)))).
+step(add(rule(355, (((X1 * (X2 * (X2 + X2))) + X3) * X2) = ((X1 + (X1 + X3)) * X2)))).
+step(hard((X1 + (X3 + -(X4 + X2))) = (X3 + (X1 + -(X2 + X4))))).
+step(add(rule(356, ((X1 + (X2 * (X3 * X1))) * (X1 * X1)) = (X1 + (X2 * (X3 * X1)))))).
+step(add(rule(357, ((X1 + (X2 * (X3 * (X4 * X4)))) * X4) = ((X1 + (X2 * X3)) * X4)))).
+step(add(rule(358, ((X1 + (X2 * (X3 * (X3 + X3)))) * X3) = ((X1 + (X2 + X2)) * X3)))).
+step(hard(((-(X1 + X2) + X4) * X3) = ((-(X2 + X1) + X4) * X3))).
+step(add(rule(359, ((-X1 + X2) * (X1 * -X1)) = ((-X2 + X1) * (X1 * X1))))).
+step(add(rule(360, (-X1 + (X1 * (X2 * X1))) = (X1 * ((-X1 + X2) * X1))))).
+step(add(rule(361, (-X1 + (X2 * (X1 * -X1))) = ((X1 + X2) * (X1 * -X1))))).
+step(add(rule(362, (-X1 + (X1 * (X1 * X2))) = (X1 * (X1 * (-X1 + X2)))))).
+step(add(rule(363, (-X1 + (X1 * (X2 * -X1))) = (X1 * ((X1 + X2) * -X1))))).
+step(add(rule(364, ((X1 + X1) * ((X1 * (X1 * X2)) + X3)) = ((X1 + X1) * (X2 + X3))))).
+step(add(rule(365, ((X1 + X1) * (X2 + (X1 * (X1 * -X2)))) = 0))).
+step(add(rule(366, ((X1 + X1) * (X2 + (X1 * (X1 * X3)))) = ((X1 + X1) * (X2 + X3))))).
+step(add(rule(367, (X1 * ((X1 + X1) * -(X1 + X1))) = -(X1 + (X1 + (X1 + X1)))))).
+step(add(rule(368, ((X1 + X1) * (X1 + (X1 + X1))) = 0))).
+step(interreduce).
+step(delete(rule(270, (X1 * (X2 + (X3 + (X1 * (X1 * -X2))))) = (X1 * X3)))).
+step(delete(rule(275, (X1 * (X2 + (X1 * (X1 + (X1 * -X2))))) = X1))).
+step(delete(rule(305, ((X1 + X1) * (-X2 + (X1 * (X1 * X2)))) = 0))).
+step(delete(rule(314, (X1 * ((X2 + (X1 * (X1 * -X2))) * X3)) = 0))).
+step(delete(rule(337, (X1 * (X2 + (X3 * X2))) = (X1 * (X1 * ((X1 + (X1 * X3)) * X2)))))).
+step(delete(rule(365, ((X1 + X1) * (X2 + (X1 * (X1 * -X2)))) = 0))).
+step(add(rule(369, ((X1 + (X1 + X1)) * -(X1 + X1)) = 0))).
+step(add(rule(370, ((X1 + X1) * -(X1 + (X1 + X1))) = 0))).
+step(add(rule(371, ((X1 + (X1 + X1)) * ((X1 + X1) * -X2)) = 0))).
+step(add(rule(372, ((X1 + (X1 + X1)) * -(X1 + (X1 + (X1 + X1)))) = 0))).
+step(add(rule(373, ((X1 + X1) * ((X1 + (X1 + X1)) * -X2)) = 0))).
+step(add(rule(374, ((X1 + X1) * ((X1 + (X1 + X1)) * X2)) = 0))).
+step(add(rule(375, ((X1 + (X1 + (X1 + X1))) * (X1 + (X1 + X1))) = 0))).
+step(add(rule(376, ((X1 + (X1 + X1)) * ((X1 + X1) * X2)) = 0))).
+step(add(rule(377, ((X1 + (X1 + X1)) * (X1 + (X1 + (X1 + X1)))) = 0))).
+step(add(rule(378, ((X1 + X1) * (X2 * (X1 + (X1 + X1)))) = 0))).
+step(add(rule(379, ((X1 + (X1 + X1)) * (X2 * (X1 + X1))) = 0))).
+step(hard((X1 + (X2 + (-X3 + X4))) = (X4 + (-X3 + (X2 + X1))))).
+step(add(rule(380, (X1 + (-X2 + (X3 + X4))) = (X3 + (-X2 + (X1 + X4)))))).
+step(hard((X2 + -X1) = (-(X1 + X4) + (X2 + X4)))).
+step(hard((X1 + (X2 + (X3 + X4))) = (X3 + (X2 + (X1 + X4))))).
+step(hard((X1 + (-(X3 + X2) + X4)) = (X1 + (X4 + -(X2 + X3))))).
+step(hard((X2 + (-(X3 + X1) + X4)) = (X2 + (-(X1 + X3) + X4)))).
+step(hard((X1 + (X3 + -(X4 + X2))) = (X1 + (X3 + -(X2 + X4))))).
+step(hard((X1 + -(X4 + (X3 + X2))) = (X1 + -(X4 + (X2 + X3))))).
+step(add(rule(381, (-X1 + (X2 + (X1 * -X1))) = (X2 + -(X1 + (X1 * X1)))))).
+step(hard(-(((X1 + X2) * X3) + X4) = -(X4 + ((X2 + X1) * X3)))).
+step(add(rule(382, ((X1 + (X1 * X2)) * (X2 * -X2)) = (X1 * -(X2 + (X2 * X2)))))).
+step(add(rule(383, (((X1 * (X2 * X2)) + X3) * (X2 * X4)) = ((X1 + X3) * (X2 * X4))))).
+step(add(rule(384, ((X1 + (X2 * (X3 * X3))) * (X3 * X4)) = ((X1 + X2) * (X3 * X4))))).
+step(hard((-(X2 + (X3 + X1)) + X4) = (X4 + -(X2 + (X1 + X3))))).
+step(hard((-(X2 + (X3 + X1)) + X4) = (-(X3 + (X1 + X2)) + X4))).
+step(hard((-(X2 + (X3 + X1)) + X4) = (X4 + -(X3 + (X2 + X1))))).
+step(hard((X2 + -(X1 + (X3 + X4))) = (X2 + -(X4 + (X3 + X1))))).
+step(hard((X1 + (X3 + -(X4 + X2))) = (X3 + (-(X2 + X4) + X1)))).
+step(hard(-(X3 + (X4 + (X1 + X2))) = -(X4 + (X1 + (X3 + X2))))).
+step(hard(-(X3 + (X4 + (X1 + X2))) = -(X1 + (X4 + (X2 + X3))))).
+step(hard((X2 + -(X1 + (X3 + X4))) = (X2 + -(X3 + (X1 + X4))))).
+step(hard(-(X3 + (X4 + (X1 + X2))) = -(X3 + (X1 + (X4 + X2))))).
+step(hard(-(X3 + (X4 + (X1 + X2))) = -(X1 + (X3 + (X2 + X4))))).
+step(hard((X2 + -(X1 + (X3 + X4))) = (-(X3 + (X4 + X1)) + X2))).
+step(hard((X1 + (-(X3 + X5) + X4)) = (X4 + (-(X5 + X3) + X1)))).
+step(add(rule(385, (X1 * (X1 * (-X1 + ((X1 + X1) * X2)))) = (-X1 + (X1 * (X2 + X2)))))).
+step(add(rule(386, (X1 + (X1 * (X2 + ((X1 * -X1) + X3)))) = (X1 * (X3 + X2))))).
+step(add(rule(387, -(X1 + (X1 + (X1 + X1))) = (X1 + X1)))).
+step(add(rule(388, -(X1 + (X1 + X1)) = (X1 + (X1 + X1))))).
+step(add(rule(389, (X1 + (X1 + (X1 + X1))) = -(X1 + X1)))).
+step(add(rule(390, ((X1 + X1) * -(X2 + X2)) = (X1 * (X2 + X2))))).
+step(add(rule(391, ((X1 + X1) * (X2 + (X2 + X2))) = 0))).
+step(add(rule(392, ((X1 + (X1 + X1)) * (X2 + X2)) = 0))).
+step(add(rule(393, ((X1 + X1) * (X2 + X2)) = (X1 * -(X2 + X2))))).
+step(hard((X1 * (X2 + (-X3 + (X4 + X3)))) = (X1 * (X2 + X4)))).
+step(add(rule(394, (X1 + (X1 * (X2 + (X3 + (X1 * -X1))))) = (X1 * (X2 + X3))))).
+step(add(rule(395, (((X1 + X2) * X3) + (X4 + (X2 * -X3))) = ((X1 * X3) + X4)))).
+step(hard(((X1 * X2) + X3) = (X3 + ((-X4 + (X1 + X4)) * X2)))).
+step(hard(-(X1 + ((X2 + X3) * X4)) = -(X1 + ((X3 + X2) * X4)))).
+step(add(rule(396, ((X1 * -X3) + (((X1 + X2) * X3) + X4)) = (X4 + (X2 * X3))))).
+step(add(rule(397, (((X1 + X2) * X3) + (X4 + (X1 * -X3))) = ((X2 * X3) + X4)))).
+step(hard(((-X1 + (X3 + (X4 + X1))) * X2) = ((X3 + X4) * X2))).
+step(hard(((X1 + X3) * X2) = ((-X4 + (X1 + (X3 + X4))) * X2))).
+step(add(rule(398, ((X1 * (X2 + X2)) + (((X1 + X1) * -X2) + X3)) = X3))).
+step(hard(X1 = (-(X2 + X2) + (X1 + (X2 + X2))))).
+step(hard(((X1 * X2) + X3) = ((X1 * (-X4 + (X2 + X4))) + X3))).
+step(add(rule(399, ((X1 * (X2 + X2)) + (X3 + ((X1 + X1) * -X2))) = X3))).
+step(add(rule(400, (((X1 + X1) * X2) + ((X1 * -(X2 + X2)) + X3)) = X3))).
+step(hard(X1 = (-X2 + (X1 + X2)))).
+step(add(rule(401, (((X1 + X1) * X2) + (X3 + (X1 * -(X2 + X2)))) = X3))).
+step(add(rule(402, (X1 + ((X2 + ((X1 * -X1) + X3)) * X1)) = ((X3 + X2) * X1)))).
+step(hard(((X1 + (-X2 + (X3 + X2))) * X4) = ((X1 + X3) * X4))).
+step(add(rule(403, (X1 + ((X2 + (X3 + (X1 * -X1))) * X1)) = ((X2 + X3) * X1)))).
+step(interreduce).
+step(delete(rule(124, ((X1 + (X1 + (X1 + X1))) * X2) = (X1 * (X2 + (X2 + (X2 + X2))))))).
+step(delete(rule(176, (X1 * ((X1 + X1) * (X1 + X1))) = (X1 + (X1 + (X1 + X1)))))).
+step(delete(rule(188, ((X1 + (X1 + X1)) * -X2) = (X1 * -(X2 + (X2 + X2)))))).
+step(add(rule(404, ((X1 + (X1 + X1)) * -X2) = (X1 * (X2 + (X2 + X2)))))).
+step(delete(rule(192, ((X1 + X1) * (X2 + (X2 + (X2 + X2)))) = (X1 * (X2 + X2))))).
+step(delete(rule(262, ((X1 + X1) * (X2 + (X2 + X2))) = ((X1 + (X1 + X1)) * (X2 + X2))))).
+step(delete(rule(271, ((X1 + X1) * (X2 + X2)) = (X1 * ((X1 + X1) * ((X1 + X1) * X2)))))).
+step(add(rule(405, (X1 * -(X2 + X2)) = (X1 * ((X1 + X1) * ((X1 + X1) * X2)))))).
+step(delete(rule(272, ((X1 + X1) * ((X1 + X1) * (X2 + X2))) = (X1 * ((X1 + X1) * X2))))).
+step(delete(rule(367, (X1 * ((X1 + X1) * -(X1 + X1))) = -(X1 + (X1 + (X1 + X1)))))).
+step(delete(rule(368, ((X1 + X1) * (X1 + (X1 + X1))) = 0))).
+step(delete(rule(370, ((X1 + X1) * -(X1 + (X1 + X1))) = 0))).
+step(delete(rule(371, ((X1 + (X1 + X1)) * ((X1 + X1) * -X2)) = 0))).
+step(delete(rule(372, ((X1 + (X1 + X1)) * -(X1 + (X1 + (X1 + X1)))) = 0))).
+step(delete(rule(373, ((X1 + X1) * ((X1 + (X1 + X1)) * -X2)) = 0))).
+step(delete(rule(375, ((X1 + (X1 + (X1 + X1))) * (X1 + (X1 + X1))) = 0))).
+step(delete(rule(377, ((X1 + (X1 + X1)) * (X1 + (X1 + (X1 + X1)))) = 0))).
+step(delete(rule(387, -(X1 + (X1 + (X1 + X1))) = (X1 + X1)))).
+step(add(rule(406, ((X1 + (X1 + X1)) * -(X2 + X2)) = 0))).
+step(add(rule(407, ((X1 + (X1 + X1)) * (X1 * -(X1 + X1))) = 0))).
+step(add(rule(408, ((X1 + X1) * (X2 * (X3 + (X3 + X3)))) = 0))).
+step(add(rule(409, ((X1 + X1) * ((X2 + (X2 + X2)) * X3)) = 0))).
+step(add(rule(410, ((X1 + (X1 + X1)) * -X2) = ((X1 + (X1 + X1)) * X2)))).
+step(add(rule(411, ((X1 + (X1 + X1)) * (X2 * -(X3 + X3))) = 0))).
+step(add(rule(412, ((X1 + X1) * ((X1 + X1) * X2)) = (X1 * (X1 * -(X2 + X2)))))).
+step(add(rule(413, (X1 * ((X1 + X1) * ((X1 + X1) * X2))) = ((X1 + X1) * -X2)))).
+step(add(rule(414, (X1 + ((X2 + X2) * (X3 * X1))) = (X1 + (X2 * ((X3 + X3) * X1)))))).
+step(add(rule(415, (X1 + (X2 * ((X3 + X3) * X4))) = ((X2 * (X3 * (X4 + X4))) + X1)))).
+step(add(rule(416, (X1 + ((X2 + X2) * (X3 * X4))) = ((X2 * (X3 * (X4 + X4))) + X1)))).
+step(add(rule(417, (X1 + ((X2 + X2) * (X3 * X4))) = ((X2 * ((X3 + X3) * X4)) + X1)))).
+step(add(rule(418, (X1 + (X2 + ((X3 + X3) * X4))) = (X1 + ((X3 * (X4 + X4)) + X2))))).
+step(add(rule(419, ((X1 + (X1 + X1)) * ((X2 + X2) * X3)) = 0))).
+step(add(rule(420, ((X1 + (X1 + X1)) * (X2 * (X3 + X3))) = 0))).
+step(add(rule(421, ((X1 * (X2 + X2)) + (X3 + X4)) = (X3 + (X4 + ((X1 + X1) * X2)))))).
+step(add(rule(422, (X1 * (X2 * -(X3 + X3))) = ((X1 + X1) * ((X2 + X2) * X3))))).
+step(add(rule(423, (X1 + (X1 + (X2 + (X1 + X1)))) = (X2 + -(X1 + X1))))).
+step(add(rule(424, ((X1 + X1) * (X2 * (X3 + X3))) = (X1 * (X2 * -(X3 + X3)))))).
+step(add(rule(425, (X1 + (X1 + (X1 + (X1 + X2)))) = (-(X1 + X1) + X2)))).
+step(add(rule(426, (X1 * ((X2 * (X3 + X3)) + X4)) = (X1 * (X4 + ((X2 + X2) * X3)))))).
+step(add(rule(427, (X1 + (X2 + ((X3 + X3) * X4))) = (X2 + ((X3 * (X4 + X4)) + X1))))).
+step(add(rule(428, (X1 + (X2 + (X3 * (X4 + X4)))) = (X1 + (X2 + ((X3 + X3) * X4)))))).
+step(add(rule(429, (X1 + (X2 * (X3 * (X4 + X4)))) = (X1 + (X2 * ((X3 + X3) * X4)))))).
+step(add(rule(430, (X1 + (X2 * (X3 * (X4 + X4)))) = (X1 + ((X2 + X2) * (X3 * X4)))))).
+step(hard((X1 + (X2 + ((X3 + X3) * X4))) = (X2 + (X1 + (X3 * (X4 + X4)))))).
+step(add(rule(431, (X1 + ((X2 + X2) * (X3 * X4))) = (X1 + (X2 * ((X3 + X3) * X4)))))).
+step(add(rule(432, (X1 + (X2 * (X3 * (X4 + X4)))) = ((X2 * ((X3 + X3) * X4)) + X1)))).
+step(add(rule(433, (X1 + (X2 * (X3 * (X4 + X4)))) = (((X2 + X2) * (X3 * X4)) + X1)))).
+step(add(rule(434, (X1 + (X2 + (X3 * (X4 + X4)))) = (X1 + (((X3 + X3) * X4) + X2))))).
+step(add(rule(435, (((X1 + X1) * X2) + (X3 + X4)) = (X3 + (X4 + (X1 * (X2 + X2))))))).
+step(add(rule(436, (X1 * (((X2 + X2) * X3) + X4)) = (X1 * (X4 + (X2 * (X3 + X3))))))).
+step(add(rule(437, (((X1 + X1) * (X2 * X3)) + X4) = (X4 + (X1 * ((X2 + X2) * X3)))))).
+step(add(rule(438, (X1 + (X2 + (X3 * (X4 + X4)))) = (X2 + (((X3 + X3) * X4) + X1))))).
+step(add(rule(439, ((X1 * (X2 + X2)) + ((-X1 + X3) * X2)) = ((X1 + X3) * X2)))).
+step(hard(((X1 + (X4 + X2)) * X3) = ((X1 + (X2 + X4)) * X3))).
+step(hard(((X1 + X2) * X3) = ((-X1 + (X2 + (X1 + X1))) * X3))).
+step(add(rule(440, ((X1 * (X2 + X2)) + ((X3 + -X1) * X2)) = ((X1 + X3) * X2)))).
+step(add(rule(441, ((X1 + (X1 + X1)) * (X2 * X3)) = (X1 * ((X2 + (X2 + X2)) * X3))))).
+step(add(rule(442, ((X1 + (X1 * (X2 * (X2 + X2)))) * (X2 + X2)) = 0))).
+step(add(rule(443, (X1 * (X2 * (X3 + (X3 + X3)))) = (X1 * ((X2 + (X2 + X2)) * X3))))).
+step(add(rule(444, (X1 * (X2 * (X3 + (X3 + X3)))) = ((X1 + (X1 + X1)) * (X2 * X3))))).
+step(add(rule(445, ((X1 + X1) * (X2 + (X1 * ((X1 + X1) * X2)))) = 0))).
+step(add(rule(446, (((X1 + X1) * X2) + (X1 * (-X2 + X3))) = (X1 * (X2 + X3))))).
+step(hard((X1 * (X2 * (X4 + X3))) = (X1 * (X2 * (X3 + X4))))).
+step(hard((X1 * (X2 + X3)) = (X1 * (-X2 + (X3 + (X2 + X2)))))).
+step(add(rule(447, (X1 * (X2 + (X2 * (X1 * X1)))) = ((X1 + X1) * X2)))).
+step(hard((X1 * (X1 * -(X1 + X2))) = (X1 * (X1 * -(X2 + X1))))).
+step(add(rule(448, (((X1 + X1) * X2) + (X1 * (X3 + -X2))) = (X1 * (X2 + X3))))).
+step(add(rule(449, ((X1 + ((X2 + X2) * X3)) * X4) = (((X2 * (X3 + X3)) + X1) * X4)))).
+step(add(rule(450, ((X1 + (X2 * (X3 + X3))) * X4) = ((((X2 + X2) * X3) + X1) * X4)))).
+step(hard((X1 * (X3 + (X1 * (-X2 + (X1 + X2))))) = (X1 + (X1 * X3)))).
+step(add(rule(451, ((X1 + (((X1 * -X2) + X3) * X2)) * X2) = (X3 * (X2 * X2))))).
+step(hard((X1 * X2) = ((-X2 + (X1 + X2)) * X2))).
+step(add(rule(452, (X1 * (X1 * (X2 * X1))) = (X2 * X1)))).
+step(add(rule(453, ((X1 + ((X2 + (X1 * -X3)) * X3)) * X3) = (X2 * (X3 * X3))))).
+step(add(rule(454, (X1 * (X1 * (X1 + (X2 * X1)))) = (X1 + (X2 * X1))))).
+step(hard((((X1 * (X1 + X2)) + X3) * X1) = (((X1 * (X2 + X1)) + X3) * X1))).
+step(hard((X1 + (X2 * ((X3 + X4) * X1))) = (X1 + (X2 * ((X4 + X3) * X1))))).
+step(add(rule(455, (X1 * (X3 + (X1 * (X2 * X3)))) = (X1 * (X1 * ((X2 + X1) * X3)))))).
+step(hard((X1 + (X2 + (X3 + (X4 + X5)))) = (X3 + (X5 + (X4 + (X1 + X2)))))).
+step(interreduce).
+step(delete(rule(112, ((X1 + (X1 + X1)) * (X1 * X1)) = (X1 + (X1 + X1))))).
+step(delete(rule(209, (X1 + (X1 * ((X2 + X2) * X3))) = (X1 + (X1 * (X2 * (X3 + X3))))))).
+step(delete(rule(323, (X1 + (X2 * (X3 * (X1 + X1)))) = (X1 + ((X2 + X2) * (X3 * X1)))))).
+step(delete(rule(325, (X1 + (X2 * (X3 * (X1 + X1)))) = (X1 + (X2 * ((X3 + X3) * X1)))))).
+step(delete(rule(369, ((X1 + (X1 + X1)) * -(X1 + X1)) = 0))).
+step(delete(rule(374, ((X1 + X1) * ((X1 + (X1 + X1)) * X2)) = 0))).
+step(delete(rule(376, ((X1 + (X1 + X1)) * ((X1 + X1) * X2)) = 0))).
+step(delete(rule(378, ((X1 + X1) * (X2 * (X1 + (X1 + X1)))) = 0))).
+step(delete(rule(379, ((X1 + (X1 + X1)) * (X2 * (X1 + X1))) = 0))).
+step(delete(rule(404, ((X1 + (X1 + X1)) * -X2) = (X1 * (X2 + (X2 + X2)))))).
+step(delete(rule(405, (X1 * -(X2 + X2)) = (X1 * ((X1 + X1) * ((X1 + X1) * X2)))))).
+step(delete(rule(406, ((X1 + (X1 + X1)) * -(X2 + X2)) = 0))).
+step(delete(rule(407, ((X1 + (X1 + X1)) * (X1 * -(X1 + X1))) = 0))).
+step(delete(rule(412, ((X1 + X1) * ((X1 + X1) * X2)) = (X1 * (X1 * -(X2 + X2)))))).
+step(delete(rule(414, (X1 + ((X2 + X2) * (X3 * X1))) = (X1 + (X2 * ((X3 + X3) * X1)))))).
+step(delete(rule(423, (X1 + (X1 + (X2 + (X1 + X1)))) = (X2 + -(X1 + X1))))).
+step(hard((X1 + (X2 + (X3 + (X4 + X5)))) = (X2 + (X4 + (X5 + (X3 + X1)))))).
+step(hard((X1 + (X2 + (X3 + (X4 + X5)))) = (X3 + (X4 + (X5 + (X1 + X2)))))).
+step(add(rule(456, ((X1 + X1) * ((X1 * (X1 + X1)) + X2)) = (-(X1 + X1) + ((X1 + X1) * X2))))).
+step(hard((X1 * ((X2 + (X4 + X4)) * X3)) = (X1 * ((X4 + (X4 + X2)) * X3)))).
+step(hard((X1 * (X2 * (X3 + (X4 + X4)))) = (X1 * (X2 * (X4 + (X4 + X3)))))).
+step(hard((X1 + ((X1 * (X1 * X2)) + X3)) = (X3 + (X1 * (X1 * (X1 + X2)))))).
+step(add(rule(457, ((X1 * (X1 * (X2 + X1))) + X3) = (X1 + ((X1 * (X1 * X2)) + X3))))).
+step(add(rule(458, (X1 + (X2 + (X1 * (X1 * X3)))) = (X2 + (X1 * (X1 * (X3 + X1))))))).
+step(hard((X1 + -(X2 + X2)) = (X2 + (X1 + (X2 + (X2 + X2)))))).
+step(hard((X1 + (X1 + (X2 + (X1 + X1)))) = (X2 + -(X1 + X1)))).
+step(hard((X1 * (X2 + (X1 * (X3 + X1)))) = (X1 * (X2 + (X1 * (X1 + X3)))))).
+step(hard((X1 + (X1 * ((X1 + X1) * X2))) = (X1 * (X1 * (X2 + (X1 + X2)))))).
+step(hard((X1 + ((X1 * (X2 * X1)) + X3)) = (X3 + (X1 * ((X1 + X2) * X1))))).
+step(add(rule(459, ((X1 * ((X2 + X1) * X1)) + X3) = (X1 + ((X1 * (X2 * X1)) + X3))))).
+step(add(rule(460, (X1 + (X2 + (X1 * (X3 * X1)))) = (X2 + (X1 * ((X3 + X1) * X1)))))).
+step(hard((X1 * (X2 + ((X3 + X1) * X1))) = (X1 * (X2 + ((X1 + X3) * X1))))).
+step(hard((X1 + (X1 * (X2 * (X1 + X1)))) = (X1 * ((X2 + (X1 + X2)) * X1)))).
+step(add(rule(461, ((X4 * -X2) + (X3 + ((X1 + X4) * X2))) = ((X1 * X2) + X3)))).
+step(hard(((X1 + X3) * X2) = ((-X4 + (X3 + (X1 + X4))) * X2))).
+step(hard(((X1 * X2) + X3) = (-X2 + (X3 + (X2 + (X1 * X2)))))).
+step(hard(((X1 * X2) + X3) = (X3 + ((-X5 + (X1 + X5)) * X2)))).
+step(hard(((-X3 + X1) * X2) = ((-(X4 + X3) + (X1 + X4)) * X2))).
+step(add(rule(462, (X1 + (((X2 + X2) * X3) + X4)) = ((X2 * (X3 + X3)) + (X4 + X1))))).
+step(hard(((X1 * (X2 + X2)) + (X3 + X4)) = (((X1 + X1) * X2) + (X4 + X3)))).
+step(hard((((X1 * (X1 + X2)) + X3) * X1) = ((X3 + (X1 * (X2 + X1))) * X1))).
+step(hard(((((X1 + X2) * X1) + X3) * X1) = ((X3 + ((X2 + X1) * X1)) * X1))).
+step(add(rule(463, (X1 * (X1 * ((X1 + X2) * X2))) = (X1 * ((X2 + X1) * (X2 * X2)))))).
+step(add(rule(464, (X1 * ((X1 + X2) * (X1 * X2))) = (X1 * (X2 * ((X2 + X1) * X2)))))).
+step(add(rule(465, ((X1 + (X1 * (X2 * X3))) * X2) = (X1 * (X2 * ((X2 + X3) * X2)))))).
+step(add(rule(466, (X1 * (X2 + (X3 * (X2 + X2)))) = (X1 * ((X3 + (X1 * (X1 + (X1 * X3)))) * X2))))).
+step(add(rule(467, (X1 * ((X2 + X1) * (X1 * X2))) = (X1 * (X2 * ((X2 + X1) * X2)))))).
+step(hard(((X1 * X2) + ((X3 + X1) * X4)) = ((X1 * (X4 + X2)) + (X3 * X4)))).
+step(add(rule(468, ((X1 * X2) + ((X3 + X1) * X4)) = ((X3 * X4) + (X1 * (X2 + X4)))))).
+step(interreduce).
+step(delete(rule(235, ((X1 * X2) + (X3 * (X4 + X2))) = (((X3 + X1) * X2) + (X3 * X4))))).
+step(delete(rule(256, ((X1 * (X2 + X3)) + (X4 * X3)) = ((X1 * X2) + ((X4 + X1) * X3))))).
+step(delete(rule(258, (((X1 + X2) * X3) + (X2 * X4)) = ((X1 * X3) + (X2 * (X4 + X3)))))).
+step(hard((X1 * ((X2 + (X4 + X4)) * X3)) = (X1 * ((X4 + (X2 + X4)) * X3)))).
+step(add(rule(469, ((X1 * X2) + (X3 * (X2 + X4))) = ((X3 * X4) + ((X3 + X1) * X2))))).
+step(hard((X1 * (X1 * (X2 + (X3 + X1)))) = (X1 * (X1 * (X1 + (X2 + X3)))))).
+step(add(rule(470, (X1 * (X2 + (X1 * (X2 + X1)))) = (X1 + ((X1 + (X1 * X1)) * X2))))).
+step(hard((X1 * ((X2 + (X3 + X1)) * X1)) = (X1 * ((X1 + (X2 + X3)) * X1)))).
+step(add(rule(471, ((X1 + (X2 + (X2 * X2))) * (X2 * X2)) = ((X2 + ((X1 + X2) * X2)) * X2)))).
+step(hard(((X1 * X2) + (X3 * (X4 + X2))) = (((X3 + X1) * X2) + (X3 * X4)))).
+step(hard((X1 * (X2 * (X3 + (X4 + X4)))) = (X1 * (X2 * (X4 + (X3 + X4)))))).
+step(hard(((X1 * (X2 * X2)) + (X3 + X2)) = (X3 + ((X1 + X2) * (X2 * X2))))).
+step(hard(((X1 * (X2 * X1)) + (X3 + X1)) = (X3 + (X1 * ((X1 + X2) * X1))))).
+step(add(rule(472, ((X1 + ((X1 + X2) * X2)) * X2) = (X2 + (X1 * (X2 + (X2 * X2))))))).
+step(add(rule(473, (X1 * (X1 * (X1 + (X1 + (X1 * (X2 + X2)))))) = ((X1 + X1) * (X2 + (X1 * X1)))))).
+step(add(rule(474, (X1 * ((X1 + X2) * (X2 * X2))) = (X1 * (X1 * ((X1 + X2) * X2)))))).
+step(hard(((X1 * (X2 + X3)) + (X4 * X2)) = (((X1 + X4) * X2) + (X1 * X3)))).
+step(add(rule(475, ((X1 + (X1 * X1)) * (X1 + X1)) = ((X1 + X1) * (X1 + (X1 * X1)))))).
+step(hard((X1 + (X2 + (X3 + (X4 + X5)))) = (X2 + (X3 + (X5 + (X4 + X1)))))).
+step(hard((X3 + (X4 + (X5 + (X6 + X2)))) = (X3 + (X5 + (X6 + (X4 + X2)))))).
+step(hard((X3 + (X4 + (X5 + (X6 + X2)))) = (X3 + (X4 + (X6 + (X5 + X2)))))).
+step(add(rule(476, (X1 + (X1 + ((X2 + X2) * X1))) = ((X2 + (X1 * X1)) * (X1 + X1))))).
+step(hard(((X1 * (X2 + (X2 + X3))) + X4) = ((X1 * (X3 + (X2 + X2))) + X4))).
+step(hard((((X1 + X1) * X2) + (X3 + X4)) = (X4 + (X3 + (X1 * (X2 + X2)))))).
+step(add(rule(477, (X1 + ((X2 * (X3 + X3)) + X4)) = (X4 + (((X2 + X2) * X3) + X1))))).
+step(add(rule(478, (((X1 + (X1 + X1)) * X2) + X3) = (X3 + (X1 * (X2 + (X2 + X2))))))).
+step(add(rule(479, (X1 + (X2 * (X3 + (X3 + X3)))) = (X1 + ((X2 + (X2 + X2)) * X3))))).
+step(add(rule(480, ((X1 * (X2 + (X2 + X2))) + X3) = (X3 + ((X1 + (X1 + X1)) * X2))))).
+step(hard(((X1 * (X2 + (X3 + X3))) + X4) = (X4 + (X1 * (X3 + (X3 + X2)))))).
+step(add(rule(481, ((X1 * (X2 + (X3 * X2))) + X4) = (X4 + ((X1 + (X1 * X3)) * X2))))).
+step(add(rule(482, (((X1 + (X1 * X2)) * X3) + X4) = (X4 + (X1 * (X3 + (X2 * X3))))))).
+step(hard((((X1 + (X1 + X2)) * X3) + X4) = (((X2 + (X1 + X1)) * X3) + X4))).
+step(hard((((X1 + (X2 + X2)) * X3) + X4) = (X4 + ((X2 + (X2 + X1)) * X3)))).
+step(hard(((X3 + (X1 * (X4 + X2))) * X5) = ((X3 + (X1 * (X2 + X4))) * X5))).
+step(hard(((X1 + (X1 + (X2 + X3))) * X4) = ((X2 + (X1 + (X1 + X3))) * X4))).
+step(hard((((X1 * (X2 + X3)) + X4) * X5) = (((X1 * (X3 + X2)) + X4) * X5))).
+step(add(rule(483, ((X1 + (X1 * X2)) * (X1 + X1)) = ((X1 + X1) * (X1 + (X2 * X1)))))).
+step(add(rule(484, ((X1 + (X1 * X3)) * (X2 + X2)) = ((X1 + X1) * (X2 + (X3 * X2)))))).
+step(add(rule(485, ((X1 + (X2 + (X3 * X3))) * (X3 * X3)) = ((X3 + ((X1 + X2) * X3)) * X3)))).
+step(hard((X1 + (X1 * (X3 + (X4 + X2)))) = (X1 + (X1 * (X4 + (X3 + X2)))))).
+step(hard((X1 * (X1 * (X3 + (X1 + X2)))) = (X1 * (X1 * (X1 + (X3 + X2)))))).
+step(hard((X1 * ((X3 + (X1 + X2)) * X1)) = (X1 * ((X1 + (X3 + X2)) * X1)))).
+step(hard((X1 * (((X2 + X1) * X1) + X3)) = (X1 * (((X1 + X2) * X1) + X3)))).
+step(hard((X1 + (X4 + ((X5 + X2) * X3))) = (X4 + (((X2 + X5) * X3) + X1)))).
+step(add(rule(486, ((X1 + X1) * (X2 + (X1 * (X1 + (X1 + X1))))) = ((X1 + X1) * X2)))).
+step(interreduce).
+step(delete(rule(252, ((X1 + (X2 + (X1 * X1))) * (X1 * X1)) = ((X1 + ((X2 + X1) * X1)) * X1)))).
+step(delete(rule(313, ((X1 + (X1 * (X2 * -X2))) * (X2 + X2)) = 0))).
+step(delete(rule(442, ((X1 + (X1 * (X2 * (X2 + X2)))) * (X2 + X2)) = 0))).
+step(delete(rule(471, ((X1 + (X2 + (X2 * X2))) * (X2 * X2)) = ((X2 + ((X1 + X2) * X2)) * X2)))).
+step(delete(rule(475, ((X1 + (X1 * X1)) * (X1 + X1)) = ((X1 + X1) * (X1 + (X1 * X1)))))).
+step(delete(rule(483, ((X1 + (X1 * X2)) * (X1 + X1)) = ((X1 + X1) * (X1 + (X2 * X1)))))).
+step(add(rule(487, ((X1 + X1) * (X2 * (X3 * (X1 + (X1 + X1))))) = 0))).
+step(add(rule(488, (((X1 * (X1 + (X1 + X1))) + X2) * (X1 + X1)) = (X2 * (X1 + X1))))).
+step(add(rule(489, ((X2 + (X1 * (X1 + (X1 + X1)))) * (X1 + X1)) = (X2 * (X1 + X1))))).
+step(add(rule(490, (X1 * (X2 + X2)) = ((X1 + X1) * (? + (? + (? + X2))))))).
+step(add(rule(491, ((X1 + X1) * (X3 + (X3 + (X3 + X2)))) = ((X1 + X1) * (? + (? + (? + X2))))))).
+step(add(rule(492, (X1 * (X2 + X2)) = ((X1 + X1) * (X2 + (? + (? + ?))))))).
+step(add(rule(493, ((X1 + X1) * (X2 + (X3 + (X3 + X3)))) = ((X1 + X1) * (X2 + (? + (? + ?))))))).
+step(hard((X2 + ((X1 + (X3 + X4)) * X2)) = (X2 + ((X4 + (X3 + X1)) * X2)))).
+step(hard(((X2 + X3) * ((X1 + X1) * X4)) = ((X3 + X2) * (X1 * (X4 + X4))))).
+step(hard((X1 * ((X3 + X4) * (X2 + X2))) = ((X1 + X1) * ((X4 + X3) * X2)))).
+step(hard((X3 + ((X4 + (X5 + X2)) * X3)) = (X3 + ((X5 + (X4 + X2)) * X3)))).
+step(add(rule(494, ((X1 + ((X1 * (X2 * -X2)) + X3)) * X2) = (X3 * X2)))).
+step(add(rule(495, ((X1 + (-X2 + X3)) * X4) = ((X3 + (-X2 + X1)) * X4)))).
+step(hard(((X1 + (X2 + X3)) * X4) = ((X3 + (X2 + X1)) * X4))).
+step(add(rule(496, ((X1 + (X2 + (X1 * (X3 * -X3)))) * X3) = (X2 * X3)))).
+step(hard((X1 + X2) = (-X4 + (X2 + (X1 + X4))))).
+step(hard((X1 + X2) = (-X5 + (X2 + (X1 + X5))))).
+step(add(rule(497, ((X1 + (X2 + (X2 * (X3 * -X3)))) * X3) = (X1 * X3)))).
+step(add(rule(498, (X1 * (X2 + (X2 * (X1 * (X2 * (X1 * -X2)))))) = 0))).
+step(add(rule(499, (X1 * (X2 + ((X2 * (X1 * -X1)) + X3))) = (X1 * X3)))).
+step(add(rule(500, (X1 * (X2 * (X1 * X1))) = (X1 * X2)))).
+step(add(rule(501, (X1 * (X2 * (X1 * -X1))) = (X1 * -X2)))).
+step(add(rule(502, (X1 * ((X2 * (X1 * X1)) + X3)) = (X1 * (X2 + X3))))).
+step(add(rule(503, (X1 * (X2 + (X3 * (X1 * X1)))) = (X1 * (X3 + X2))))).
+step(add(rule(504, (X1 * (X2 * (X1 * (X1 + X1)))) = (X1 * (X2 + X2))))).
+step(add(rule(505, (X1 * (X2 * (X1 * X2))) = (X1 * (X2 * (X2 * X1)))))).
+step(add(rule(506, (X1 * (X2 + (-X3 + X4))) = (X1 * (X4 + (-X3 + X2)))))).
+step(hard((X1 * (X2 + (X3 + X4))) = (X1 * (X4 + (X3 + X2))))).
+step(add(rule(507, (X1 * (X2 + (X3 + (X3 * (X1 * -X1))))) = (X1 * X2)))).
+step(add(rule(508, (X1 * (-X2 + (X1 * ((X1 + X1) * X2)))) = (X1 * X2)))).
+step(add(rule(509, ((-X1 + (X1 * (X2 * (X2 + X2)))) * X2) = (X1 * X2)))).
+step(add(rule(510, ((X5 * -X4) + (X2 + (X1 + (X5 * X4)))) = (X1 + X2)))).
+step(hard((X1 + X2) = (-(X3 + X3) + (X2 + (X1 + (X3 + X3)))))).
+step(add(rule(511, (X1 * (X1 * (X2 * -X1))) = (X2 * -X1)))).
+step(add(rule(512, (X3 * (X2 * X2)) = (X2 * (X2 * X3))))).
+step(hard(((X1 + X1) * (X2 + X1)) = (X1 * (X1 + (X2 + (X1 + X2)))))).
+step(hard((-X1 + (X2 + (X1 + (X3 + X4)))) = (X3 + (X4 + X2)))).
+step(hard((X1 + (X2 * X3)) = (X1 + ((-X4 + (X2 + X4)) * X3)))).
+step(hard((-X1 + (X2 + (X3 + (X1 + X4)))) = (X3 + (X2 + X4)))).
+step(hard((-X1 + (X2 + (X3 + (X4 + X1)))) = (X4 + (X2 + X3)))).
+step(hard((X1 + (X2 + X3)) = (-X4 + (X2 + (X1 + (X4 + X3)))))).
+step(hard((-X1 + (X4 + (X1 + (X3 + X5)))) = (X4 + (X5 + X3)))).
+step(hard((X1 + (X2 + X3)) = (-X4 + (X2 + (X3 + (X1 + X4)))))).
+step(hard((X1 + (X2 + (-X5 + (X4 + X5)))) = (X4 + (X1 + X2)))).
+step(hard(((X1 * X2) + X3) = (X3 + ((-X6 + (X1 + X6)) * X2)))).
+step(hard(((X1 + X3) * X2) = ((-X4 + (X3 + (X4 + X1))) * X2))).
+step(add(rule(513, (-? + (((X2 + X2) * X3) + ?)) = (X2 * (X3 + X3))))).
+step(add(rule(514, (-X1 + (((X2 + X2) * X3) + X1)) = (-? + (((X2 + X2) * X3) + ?))))).
+step(add(rule(515, ((X1 + (X2 * (X2 * X1))) * X2) = (X1 * (X2 + X2))))).
+step(hard((X1 * (X2 * X2)) = (X2 * (X2 * (-X2 + (X1 + X2)))))).
+step(add(rule(516, ((X2 + (X1 * (X1 + (X1 * -X2)))) * X1) = X1))).
+step(interreduce).
+step(delete(rule(30, (X1 + (X2 * (X1 * X1))) = ((X1 + X2) * (X1 * X1))))).
+step(add(rule(517, (X1 + (X2 * (X1 * X1))) = (X1 * (X1 * (X1 + X2)))))).
+step(delete(rule(108, ((X1 + (X2 * X3)) * (X3 * X3)) = (((X1 * X3) + X2) * X3)))).
+step(add(rule(518, (X3 * (X3 * (X1 + (X2 * X3)))) = (((X1 * X3) + X2) * X3)))).
+step(delete(rule(127, (((X1 + X2) * (X1 * X1)) + X3) = (X1 + ((X2 * (X1 * X1)) + X3))))).
+step(delete(rule(128, (X1 + (X2 * (X3 * (X1 * X1)))) = ((X1 + (X2 * X3)) * (X1 * X1))))).
+step(add(rule(519, (X1 + (X2 * (X3 * (X1 * X1)))) = (X1 * (X1 * (X1 + (X2 * X3))))))).
+step(delete(rule(129, (X1 + (X2 + (X3 * (X1 * X1)))) = (X2 + ((X1 + X3) * (X1 * X1)))))).
+step(delete(rule(131, ((X1 + (X2 + X2)) * (X1 * X1)) = (X1 + (X2 * (X1 * (X1 + X1))))))).
+step(add(rule(520, (X1 * (X1 * (X1 + (X2 + X2)))) = (X1 + (X2 * (X1 * (X1 + X1))))))).
+step(delete(rule(136, (((X1 + X2) * (X2 * X2)) + X3) = (X2 + ((X1 * (X2 * X2)) + X3))))).
+step(delete(rule(138, (((X1 * X2) + X3) * (X2 * X2)) = ((X1 + (X3 * X2)) * X2)))).
+step(add(rule(521, (X2 * (X2 * ((X1 * X2) + X3))) = ((X1 + (X3 * X2)) * X2)))).
+step(delete(rule(238, (X1 + ((X2 + X3) * (X3 * X3))) = (X3 + (X1 + (X2 * (X3 * X3))))))).
+step(add(rule(522, (X1 + (X3 * (X3 * (X2 + X3)))) = (X3 + (X1 + (X2 * (X3 * X3))))))).
+step(delete(rule(239, (X1 + ((X2 + X3) * (X2 * X2))) = ((X3 * (X2 * X2)) + (X1 + X2))))).
+step(add(rule(523, (X1 + (X2 * (X2 * (X2 + X3)))) = ((X3 * (X2 * X2)) + (X1 + X2))))).
+step(delete(rule(250, ((X1 + ((X1 * X1) + X2)) * (X1 * X1)) = ((X1 + ((X2 + X1) * X1)) * X1)))).
+step(add(rule(524, ((X1 + ((X2 + X1) * X1)) * X1) = (X1 * (X1 + (X1 * (X2 + X1))))))).
+step(delete(rule(251, ((X1 + (X1 * (X2 * X3))) * X3) = (X1 * ((X2 + X3) * (X3 * X3)))))).
+step(add(rule(525, ((X1 + (X1 * (X2 * X3))) * X3) = (X1 * (X3 * (X3 * (X2 + X3))))))).
+step(delete(rule(259, ((X1 + (X1 * (X2 * X3))) * X3) = (X1 * ((X3 + X2) * (X3 * X3)))))).
+step(add(rule(526, ((X1 + (X1 * (X2 * X3))) * X3) = (X1 * (X3 * (X3 * (X3 + X2))))))).
+step(delete(rule(334, (X2 + (X1 * (X2 * -X2))) = ((-X1 + X2) * (X2 * X2))))).
+step(add(rule(527, (X2 + (X1 * (X2 * -X2))) = (X2 * (X2 * (-X1 + X2)))))).
+step(delete(rule(346, (-X1 + (X2 * (X1 * X1))) = ((-X1 + X2) * (X1 * X1))))).
+step(add(rule(528, (-X1 + (X2 * (X1 * X1))) = (X1 * (X1 * (-X1 + X2)))))).
+step(delete(rule(356, ((X1 + (X2 * (X3 * X1))) * (X1 * X1)) = (X1 + (X2 * (X3 * X1)))))).
+step(add(rule(529, (X1 * (X1 * (X1 + (X2 * (X3 * X1))))) = (X1 + (X2 * (X3 * X1)))))).
+step(delete(rule(359, ((-X1 + X2) * (X1 * -X1)) = ((-X2 + X1) * (X1 * X1))))).
+step(add(rule(530, ((-X1 + X2) * (X1 * -X1)) = (X1 * (X1 * (-X2 + X1)))))).
+step(delete(rule(447, (X1 * (X2 + (X2 * (X1 * X1)))) = ((X1 + X1) * X2)))).
+step(delete(rule(454, (X1 * (X1 * (X1 + (X2 * X1)))) = (X1 + (X2 * X1))))).
+step(delete(rule(458, (X1 + (X2 + (X1 * (X1 * X3)))) = (X2 + (X1 * (X1 * (X3 + X1))))))).
+step(delete(rule(463, (X1 * (X1 * ((X1 + X2) * X2))) = (X1 * ((X2 + X1) * (X2 * X2)))))).
+step(add(rule(531, (X1 * (X1 * ((X1 + X2) * X2))) = (X1 * (X2 * (X2 * (X2 + X1))))))).
+step(delete(rule(474, (X1 * ((X1 + X2) * (X2 * X2))) = (X1 * (X1 * ((X1 + X2) * X2)))))).
+step(add(rule(532, (X1 * (X2 * (X2 * (X1 + X2)))) = (X1 * (X1 * ((X1 + X2) * X2)))))).
+step(delete(rule(485, ((X1 + (X2 + (X3 * X3))) * (X3 * X3)) = ((X3 + ((X1 + X2) * X3)) * X3)))).
+step(add(rule(533, ((X3 + ((X1 + X2) * X3)) * X3) = (X3 * (X3 + (X3 * (X1 + X2))))))).
+step(delete(rule(492, (X1 * (X2 + X2)) = ((X1 + X1) * (X2 + (? + (? + ?))))))).
+step(delete(rule(493, ((X1 + X1) * (X2 + (X3 + (X3 + X3)))) = ((X1 + X1) * (X2 + (? + (? + ?))))))).
+step(add(rule(534, ((X1 + X1) * (X2 + (X3 + (X3 + X3)))) = ((X1 + X1) * (? + (? + (? + X2))))))).
+step(delete(rule(513, (-? + (((X2 + X2) * X3) + ?)) = (X2 * (X3 + X3))))).
+step(delete(rule(514, (-X1 + (((X2 + X2) * X3) + X1)) = (-? + (((X2 + X2) * X3) + ?))))).
+step(add(rule(535, (-X1 + (((X2 + X2) * X3) + X1)) = ((X2 + X2) * X3)))).
+step(simplify_queue).
+step(add(rule(536, (X1 * ((X1 + (X2 * X1)) * X1)) = (X1 + (X1 * X2))))).
+step(add(rule(537, ((X2 + (X1 * X2)) * X2) = (X2 * (X2 + (X2 * X1)))))).
+step(add(rule(538, (X1 * (X2 * (X3 * X3))) = (X3 * (X3 * (X1 * X2)))))).
+step(add(rule(539, (X1 * (X2 * (X2 + X2))) = (X2 * (X2 * (X1 + X1)))))).
+step(hard((X1 * X2) = (X1 * (-X1 + (X2 + X1))))).
+step(add(rule(540, (X1 * (X2 * -X2)) = (X2 * (X2 * -X1))))).
+step(add(rule(541, ((X1 + X1) * X2) = (X2 * (X2 * (X1 * (X2 + X2))))))).
+step(add(rule(542, (X1 * (X1 * (X2 * X3))) = (X2 * (X1 * (X1 * X3)))))).
+step(add(rule(543, (X2 * X1) = (X1 * X2)))).
+
+lemma((X1 + 0) = X1).
+lemma((X1 + (-X1 + X2)) = X2).
+lemma(-(-X1) = X1).
+lemma((X2 + (X1 + -X2)) = X1).
+lemma((X1 * (X1 * (X1 * X2))) = (X1 * X2)).
+lemma((X1 + (X2 + -(X1 + X2))) = 0).
+lemma((X1 * ((X1 * X1) + X2)) = (X1 + (X1 * X2))).
+lemma((X1 * 0) = 0).
+lemma((-X1 * -(-X1 * -X1)) = X1).
+lemma((X1 + (X1 * (X1 * X2))) = (X1 * (X1 * (X1 + X2)))).
+lemma((0 * X1) = 0).
+lemma(((X1 * (X2 * X4)) + (X3 * X4)) = (((X1 * X2) + X3) * X4)).
+lemma(((X1 * X4) + (X2 * (X3 * X4))) = ((X1 + (X2 * X3)) * X4)).
+lemma((X1 * (X2 * (X1 * (X2 * (X1 * X2))))) = (X1 * X2)).
+lemma(-(X1 * X2) = (X1 * -X2)).
+lemma((-X1 * X2) = (X1 * -X2)).
+lemma(((X1 + (X1 * (X2 * -X2))) * (X2 * X3)) = 0).
+lemma(((X1 + (((X1 * -X2) + X3) * X2)) * X2) = (X3 * (X2 * X2))).
+lemma((X1 * (X1 * (X2 * X1))) = (X2 * X1)).
+lemma((X1 * (X2 * (X1 * X1))) = (X1 * X2)).
+lemma((X1 * (X2 * (X3 * X3))) = (X3 * (X3 * (X1 * X2)))).
diff --git a/misc/test.hs b/misc/test.hs
new file mode 100644
--- /dev/null
+++ b/misc/test.hs
@@ -0,0 +1,161 @@
+{-# LANGUAGE TemplateHaskell, FlexibleInstances, FlexibleContexts, UndecidableInstances, StandaloneDeriving, ScopedTypeVariables, TupleSections, DeriveGeneric #-}
+import Twee.Constraints
+import Twee.Term hiding (subst, canonicalise, F)
+import Twee.Term.Core hiding (F)
+import Test.QuickCheck hiding (Function, Fun)
+import Test.QuickCheck.All
+import Twee.Pretty
+import Twee.CP
+import Twee.Proof
+import qualified Twee.KBO as Ord
+import Text.PrettyPrint
+import Twee.Base hiding (F)
+import Twee.Rule
+import Twee.Equation
+import Control.Monad
+import qualified Data.Map as Map
+import Data.Maybe
+import Data.Ord
+import Data.List
+import Data.Typeable
+import qualified Twee.Index as Index
+import Data.Int
+import GHC.Generics
+
+newtype Func = F Int deriving (Eq, Ord, Show)
+
+instance Pretty Func where pPrint (F f) = text "f" <> int f
+instance PrettyTerm Func
+instance Arbitrary (Subst Func) where
+  arbitrary = fmap fromJust (fmap listToSubst (liftM2 zip (fmap nub arbitrary) (infiniteListOf arbitrary)))
+instance Arbitrary Func where
+  arbitrary = F <$> choose (1, 1)
+instance Minimal Func where
+  minimal = fun (F 0)
+instance Sized Func where size _ = 1
+instance Arity Func where
+  arity (F 0) = 0
+  arity (F 1) = 2
+instance Skolem Func
+instance EqualsBonus Func
+
+instance Arbitrary Var where arbitrary = fmap V (choose (0, 3))
+instance (Ord f, Typeable f, Arbitrary f) => Arbitrary (Fun f) where
+  arbitrary = fmap fun arbitrary
+
+instance (Ord f, Typeable f, Arbitrary f, Sized f, Arity f) => Arbitrary (Term f) where
+  arbitrary =
+    sized $ \n ->
+      oneof $
+        [ build <$> var <$> arbitrary ] ++
+        [ do { f <- arbitrary; build <$> app f <$> vectorOf (arity f) (resize ((n-1) `div` arity f) arbitrary :: Gen (Term f)) } | n > 0 ]
+  shrink (App f ts0) =
+    ts ++ (build <$> app f <$> shrinkOne ts)
+    where
+      ts = unpack ts0
+      shrinkOne [] = []
+      shrinkOne (x:xs) =
+        [ y:xs | y <- shrink x ] ++
+        [ x:ys | ys <- shrinkOne xs ]
+  shrink _ = []
+
+data Pair f = Pair (Term f) (Term f) deriving Show
+
+instance (Ord f, Typeable f, Arbitrary f, Arity f, Sized f) => Arbitrary (Pair f) where
+  arbitrary = liftM2 Pair arbitrary arbitrary
+  shrink (Pair x y) =
+    [ Pair x' y  | x' <- shrink x ] ++
+    [ Pair x y'  | y' <- shrink y ] ++
+    [ Pair x' y' | x' <- shrink x, y' <- shrink y ]
+
+instance Ordered Func where
+  lessIn = Ord.lessIn
+  lessEq = Ord.lessEq
+
+instance Function f => Arbitrary (Model f) where
+  arbitrary = fmap (modelFromOrder . map Variable . nub) arbitrary
+  shrink = weakenModel
+
+prop_1 :: Model Func -> Pair Func -> Subst Func -> Property
+prop_1 model (Pair t u) sub =
+  counterexample ("Model: " ++ prettyShow model) $
+  counterexample ("Subst: " ++ prettyShow sub) $
+  conjoin $ do
+    let cp = CriticalPair (t :=: u) 0 Nothing (axiom (Axiom 0 "dummy" (t :=: u)))
+    r@(Rule _ t' u') <- map orient (map cp_eqn (split cp))
+    return $
+      counterexample ("LHS:   " ++ prettyShow t') $
+      counterexample ("RHS:   " ++ prettyShow u') $
+      counterexample ("Rule:  " ++ prettyShow r) $
+      counterexample ("Inst:  " ++ prettyShow (Rule Oriented (subst sub t') (subst sub u'))) $
+      counterexample ("Res:   " ++ show (lessIn model (subst sub u') (subst sub t'))) $
+      not (reducesInModel model r sub) || isJust (lessIn model (subst sub u') (subst sub t'))
+
+prop_2 :: Model Func -> Pair Func -> Bool
+prop_2 model (Pair t u) =
+  not (lessIn model t u == Just Strict && isJust (lessIn model u t))
+
+prop_3 :: Pair Func -> Bool
+prop_3 (Pair t u) =
+  not (lessThan t u && lessEq u t)
+
+prop_4 :: Pair Func -> Property
+prop_4 (Pair t u) =
+  t /= u ==> 
+  not (lessEq t u && lessEq u t)
+
+prop_5 :: Term Func -> Property
+prop_5 t =
+  lessEq t t .&&. not (lessThan t t)
+
+prop_paths :: Term Func -> Property
+prop_paths t =
+  forAllShrink (choose (0, len t-1)) shrink $ \n ->
+    counterexample (show (positionToPath t n)) $
+    pathToPosition t (positionToPath t n) === n
+
+deriving instance Ord f => Ord (Subst f)
+
+prop_index :: [Term Func] -> Term Func -> Property
+prop_index ts u =
+  counterexample (show ts) $
+  counterexample (show idx) $
+  sort (catMaybes [fmap (,t) (match t u) | t <- ts]) ===
+  sort (Index.matches u idx)
+  where
+    idx = foldr (\t -> Index.insert t t) Index.empty ts
+
+deriving instance Eq Symbol
+deriving instance Generic Symbol
+
+instance Arbitrary Symbol where
+  arbitrary =
+    Symbol <$>
+      arbitrary <*>
+      fmap getLarge arbitrary <*>
+      (fmap (fromIntegral . getLarge) (arbitrary :: Gen (Large Int32)) `suchThat` (> 0) `suchThat` (< 2^31))
+  shrink s =
+    filter ok (genericShrink s)
+    where
+      ok s = Twee.Term.Core.size s > 0
+
+prop_symbol_1 :: Symbol -> Property
+prop_symbol_1 s =
+  withMaxSuccess 100000 $
+  counterexample ("fun/index/size = " ++ show (isFun s, index s, Twee.Term.Core.size s)) $
+  counterexample ("n = " ++ show (fromSymbol s)) $
+  toSymbol (fromSymbol s) === twiddle s
+  where
+    twiddle s =
+      s { index = fromIntegral (fromIntegral (index s) :: Int32) }
+
+prop_symbol_2 :: Int64 -> Property
+prop_symbol_2 n =
+  withMaxSuccess 100000 $
+  fromSymbol (toSymbol n) === n
+
+return []
+main = $forAllProperties (quickCheckWithResult stdArgs { maxSuccess = 1000000 })
+
+t :: Term Func
+t = build (app (fun (F 0)) [app (fun (F 1)) [var (V 0), var (V 1)], var (V 2)])
diff --git a/tests/BOO067-1.p b/tests/BOO067-1.p
new file mode 100644
--- /dev/null
+++ b/tests/BOO067-1.p
@@ -0,0 +1,32 @@
+%--------------------------------------------------------------------------
+% File     : BOO067-1 : TPTP v6.3.0. Released v2.6.0.
+% Domain   : Boolean Algebra (Ternary)
+% Problem  : Ternary Boolean Algebra Single axiom is complete, part 1
+% Version  : [MP96] (equality) axioms.
+% English  :
+
+% Refs     : [McC98] McCune (1998), Email to G. Sutcliffe
+%          : [MP96]  McCune & Padmanabhan (1996), Automated Deduction in Eq
+% Source   : [TPTP]
+% Names    :
+
+% Status   : Unsatisfiable
+% Rating   : 0.42 v6.3.0, 0.35 v6.2.0, 0.29 v6.1.0, 0.31 v6.0.0, 0.48 v5.5.0, 0.47 v5.4.0, 0.33 v5.3.0, 0.25 v5.2.0, 0.29 v5.1.0, 0.33 v5.0.0, 0.29 v4.1.0, 0.18 v4.0.1, 0.36 v4.0.0, 0.38 v3.7.0, 0.11 v3.4.0, 0.12 v3.3.0, 0.21 v3.1.0, 0.33 v2.7.0, 0.27 v2.6.0
+% Syntax   : Number of clauses     :    2 (   0 non-Horn;   2 unit;   1 RR)
+%            Number of atoms       :    2 (   2 equality)
+%            Maximal clause size   :    1 (   1 average)
+%            Number of predicates  :    1 (   0 propositional; 2-2 arity)
+%            Number of functors    :    7 (   5 constant; 0-3 arity)
+%            Number of variables   :    7 (   0 singleton)
+%            Maximal term depth    :    5 (   3 average)
+% SPC      : CNF_UNS_RFO_PEQ_UEQ
+
+% Comments : A UEQ part of BOO035-1
+%--------------------------------------------------------------------------
+cnf(single_axiom,axiom,
+    ( multiply(multiply(A,inverse(A),B),inverse(multiply(multiply(C,D,E),F,multiply(C,D,G))),multiply(D,multiply(G,F,E),C)) = B )).
+
+cnf(prove_tba_axioms_1,negated_conjecture,
+    (  multiply(multiply(d,e,a),b,multiply(d,e,c)) != multiply(d,e,multiply(a,b,c)) )).
+
+%--------------------------------------------------------------------------
diff --git a/tests/LAT072-1.p b/tests/LAT072-1.p
new file mode 100644
--- /dev/null
+++ b/tests/LAT072-1.p
@@ -0,0 +1,37 @@
+%--------------------------------------------------------------------------
+% File     : LAT072-1 : TPTP v6.3.0. Released v2.6.0.
+% Domain   : Lattice Theory (Ortholattices)
+% Problem  : Given single axiom OML-23A, prove associativity
+% Version  : [MRV03] (equality) axioms.
+% English  : Given a single axiom candidate OML-23A for orthomodular lattices
+%            (OML) in terms of the Sheffer Stroke, prove a Sheffer stroke form
+%            of associativity.
+
+% Refs     : [MRV03] McCune et al. (2003), Sheffer Stroke Bases for Ortholatt
+% Source   : [MRV03]
+% Names    : OML-23A-associativity [MRV03]
+
+% Status   : Unsatisfiable
+% Rating   : 0.95 v6.3.0, 0.94 v6.2.0, 0.93 v6.1.0, 0.94 v6.0.0, 0.95 v5.4.0, 1.00 v2.6.0
+% Syntax   : Number of clauses     :    2 (   0 non-Horn;   2 unit;   1 RR)
+%            Number of atoms       :    2 (   2 equality)
+%            Maximal clause size   :    1 (   1 average)
+%            Number of predicates  :    1 (   0 propositional; 2-2 arity)
+%            Number of functors    :    4 (   3 constant; 0-2 arity)
+%            Number of variables   :    4 (   2 singleton)
+%            Maximal term depth    :    7 (   4 average)
+% SPC      : CNF_UNS_RFO_PEQ_UEQ
+
+% Comments :
+%--------------------------------------------------------------------------
+%----Single axiom OML-23A
+cnf(oml_23A,axiom,
+    ( f(f(f(f(B,A),f(A,C)),D),f(A,f(f(C,f(f(A,A),C)),C))) = A )).
+
+cnf(a, axiom, f(X,Y) = f(Y, X)).
+
+%----Denial of Sheffer stroke associativity
+cnf(associativity,negated_conjecture,
+    (  f(a,f(f(b,c),f(b,c))) != f(c,f(f(b,a),f(b,a))) )).
+
+%--------------------------------------------------------------------------
diff --git a/tests/ROB010-1.p b/tests/ROB010-1.p
new file mode 100644
--- /dev/null
+++ b/tests/ROB010-1.p
@@ -0,0 +1,11 @@
+cnf(condition,hypothesis,
+    ( negate(add(a,negate(b))) = c )).
+
+cnf(prove_result,negated_conjecture,
+    (  negate(add(c,negate(add(b,a)))) != a )).
+
+cnf(commutativity_of_add,axiom,
+    ( add(X,Y) = add(Y,X) )).
+
+cnf(robbins_axiom,axiom,
+    ( negate(add(negate(add(X,Y)),negate(add(X,negate(Y))))) = X )).
diff --git a/tests/append-rev.p b/tests/append-rev.p
new file mode 100644
--- /dev/null
+++ b/tests/append-rev.p
@@ -0,0 +1,4 @@
+cnf(rev_rev, axiom, rev(rev(X)) = X).
+cnf(app_assoc, axiom, '++'(X,'++'(Y,Z)) = '++'('++'(X,Y),Z)).
+cnf(rev_app, axiom, '++'(rev(X),rev(Y)) = rev('++'(Y,X))).
+cnf(conjecture, negated_conjecture, '++'(a,rev(b)) != rev('++'(b, rev(a)))).
diff --git a/tests/db.p b/tests/db.p
new file mode 100644
--- /dev/null
+++ b/tests/db.p
@@ -0,0 +1,17 @@
+% http://www.dcs.bbk.ac.uk/~szabolcs/rellat-jlamp-second-submission-2.pdf
+% appendix b. theorem 3.4, clause 8.
+cnf(a, axiom, '^'(X, Y) = '^'(Y, X)).
+cnf(a, axiom, '^'(X, '^'(Y, Z)) = '^'(Y, '^'(X, Z))).
+cnf(a, axiom, '^'('^'(X, Y), Z) = '^'(X, '^'(Y, Z))).
+cnf(a, axiom, v(X, Y) = v(Y, X)).
+cnf(a, axiom, v(X, v(Y, Z)) = v(Y, v(X, Z))).
+cnf(a, axiom, v(v(X, Y), Z) = v(X, v(Y, Z))).
+cnf(a, axiom, v(X, '^'(X, Y)) = X).
+cnf(a, axiom, '^'(X, v(X, Y)) = X).
+cnf(a, axiom, upme(X,Y,Z) = '^'(X, v(Y, Z))).
+cnf(a, axiom, lome(X,Y,Z) = v('^'(X, Y), '^'(X, Z))).
+cnf(a, axiom, upjo(X,Y,Z) = '^'(v(X, Y), v(X, Z))).
+cnf(a, axiom, lojo(X,Y,Z) = v(X, '^'(Y, Z))).
+cnf(a, axiom, v(upme('^'(a, X1),Y1,Z1), '^'(Y1, Z1)) = '^'(v('^'('^'(a, X1), Y1), Z1), v('^'('^'(a, X1), Z1), Y1))).
+cnf(a, axiom, upme(X,Y,Z) = v(upme(X,Y,'^'(a, Z)), upme(X,Z,'^'(a, Y)))).
+fof(a, conjecture, (upme(a,x2,y2) = upme(a,x2,z2) => upme(x2,y2,z2) = lome(x2,y2,z2))).
diff --git a/tests/deriv.p b/tests/deriv.p
new file mode 100644
--- /dev/null
+++ b/tests/deriv.p
@@ -0,0 +1,39 @@
+% Axioms about arithmetic.
+
+cnf('commutativity of +', axiom,
+	'+'(X, Y) = '+'(Y, X)).
+cnf('associativity of +', axiom,
+	'+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).
+cnf('commutativity of *', axiom,
+	'*'(X, Y) = '*'(Y, X)).
+cnf('associativity of *', axiom,
+	'*'(X, '*'(Y, Z)) = '*'('*'(X, Y), Z)).
+cnf('plus 0', axiom,
+	'+'('0', X) = X).
+cnf('times 0', axiom,
+	'*'('0', X) = '0').
+cnf('times 1', axiom,
+	'*'('1', X) = X).
+cnf('distributivity', axiom,
+	'*'(X, '+'(Y, Z)) = '+'('*'(X, Y), '*'(X, Z))).
+cnf('minus', axiom,
+    '+'(X, '-'(X)) = '0').
+
+cnf('derivative of 0', axiom,
+	d('0') = '0').
+cnf('derivative of 1', axiom,
+	d('1') = '0').
+cnf('derivative of x', axiom,
+	d(x) = '1').
+cnf('derivative of +', axiom,
+	d('+'(T,U)) = '+'(d(T), d(U))).
+cnf('derivative of *', axiom,
+	d('*'(T, U)) = '+'('*'(T, d(U)), '*'(U, d(T)))).
+cnf('derivative of sin', axiom,
+    d(sin(T)) = '*'(cos(T), d(T))).
+cnf('derivative of cos', axiom,
+    d(cos(T)) = '-'('*'(sin(T), d(T)))).
+
+fof(goal, conjecture,
+	?[T]: d(T) = '*'(x, cos(x))).
+    
diff --git a/tests/diff.p b/tests/diff.p
new file mode 100644
--- /dev/null
+++ b/tests/diff.p
@@ -0,0 +1,4 @@
+cnf('x\\(y\\x)=x', axiom, '\\'(X, '\\'(Y, X)) = X).
+cnf('x\\(x\\y)=y\\(y\\x)', axiom, '\\'(X, '\\'(X, Y)) = '\\'(Y, '\\'(Y, X))).
+cnf('(x\\y)\\z=(x\\z)\\(y\\z)', axiom, '\\'('\\'(X, Y), Z) = '\\'('\\'(X, Z), '\\'(Y, Z))).
+cnf(conjecture, negated_conjecture, '\\'('\\'(a, c), b) != '\\'('\\'(a, b), c)).
diff --git a/tests/group.p b/tests/group.p
new file mode 100644
--- /dev/null
+++ b/tests/group.p
@@ -0,0 +1,15 @@
+fof(identity, axiom,
+    ![X]: f(X, e) = X).
+fof(right_inverse, axiom,
+    ![X]: f(X, i(X)) = e).
+fof(associativity, axiom,
+    ![X, Y, Z]: f(X, f(Y, Z)) = f(f(X, Y), Z)).
+%fof(left_inverse, conjecture,
+%    ![X]: f(i(X),X) = e).
+%fof(left_identity, conjecture,
+%    ![X]: f(e, X) = X).
+
+fof(inverse_distrib, axiom,
+    ![X,Y]: f(i(X),i(Y)) = i(f(X,Y))).
+fof(commutativity, conjecture,
+    ![X,Y]: f(X,Y) = f(Y,X)).
diff --git a/tests/lat.p b/tests/lat.p
new file mode 100644
--- /dev/null
+++ b/tests/lat.p
@@ -0,0 +1,16 @@
+cnf(idempotence_of_meet, axiom, meet(X, X)=X).
+cnf(idempotence_of_join, axiom, join(X, X)=X).
+cnf(absorption1, axiom, meet(X, join(X, Y))=X).
+cnf(absorption2, axiom, join(X, meet(X, Y))=X).
+cnf(commutativity_of_meet, axiom, meet(X, Y)=meet(Y, X)).
+cnf(commutativity_of_join, axiom, join(X, Y)=join(Y, X)).
+cnf(associativity_of_meet, axiom,
+    meet(meet(X, Y), Z)=meet(X, meet(Y, Z))).
+cnf(associativity_of_join, axiom,
+    join(join(X, Y), Z)=join(X, join(Y, Z))).
+cnf(equation_H34, axiom,
+    meet(X, join(Y, meet(Z, U)))=meet(X,
+                                      join(Y, meet(Z, join(Y, meet(U, join(Y, Z))))))).
+cnf(prove_H28, negated_conjecture,
+    meet(a, join(b, meet(a, meet(c, d))))!=meet(a,
+                                                join(b, meet(c, meet(d, join(a, meet(b, d))))))).
diff --git a/tests/lcl.p b/tests/lcl.p
new file mode 100644
--- /dev/null
+++ b/tests/lcl.p
@@ -0,0 +1,7 @@
+cnf(wajsberg_1, axiom, implies(truth, X)=X).
+cnf(wajsberg_3, axiom,
+    implies(implies(X, Y), Y)=implies(implies(Y, X), X)).
+cnf(wajsberg_4, axiom,
+    implies(implies(not(X), not(Y)), implies(Y, X))=truth).
+cnf(lemma_antecedent, axiom, implies(X, Y)=implies(Y, X)).
+cnf(prove_wajsberg_lemma, negated_conjecture, x!=y).
diff --git a/tests/loop.p b/tests/loop.p
new file mode 100644
--- /dev/null
+++ b/tests/loop.p
@@ -0,0 +1,6 @@
+cnf(mult_ld, axiom, '*'(X, '^'(X, Y)) = Y).
+cnf(ld_mult, axiom, '^'(X, '*'(X, Y)) = Y).
+cnf(mult_rd, axiom, '*'('/'(X, Y), Y) = X).
+cnf(rd_mult, axiom, '/'('*'(X, Y), Y) = X).
+cnf(moufang, axiom, '*'(X, '*'(Y, '*'(X, Z))) = '*'('*'('*'(X, Y), X), Z)).
+cnf(conjecture, negated_conjecture, '^'(a,a) != '/'(a,a)).
diff --git a/tests/loop2.p b/tests/loop2.p
new file mode 100644
--- /dev/null
+++ b/tests/loop2.p
@@ -0,0 +1,6 @@
+cnf('*-\\', axiom, '*'(X, '\\'(X, Y)) = Y).
+cnf('\\-*', axiom, '\\'(X, '*'(X, Y)) = Y).
+cnf('*-/', axiom, '*'('/'(X, Y), Y) = X).
+cnf('/-*', axiom, '/'('*'(X, Y), Y) = X).
+cnf(moufang, axiom, '*'(X, '*'(Y, '*'(X, Z))) = '*'('*'('*'(X, Y), X), Z)).
+cnf(conjecture, negated_conjecture, '*'(a,'/'(b,b)) != a).
diff --git a/tests/lukasiewicz.p b/tests/lukasiewicz.p
new file mode 100644
--- /dev/null
+++ b/tests/lukasiewicz.p
@@ -0,0 +1,6 @@
+cnf(imp_true, axiom, implies(true, X) = X).
+cnf(imp_compose, axiom, implies(implies(X, Y), implies(implies(Y, Z), implies(X, Z))) = true).
+cnf(imp_not, axiom, implies(implies(not(X), not(Y)), implies(Y, X)) = true).
+cnf(imp_switch, axiom, implies(implies(X, Y), Y) = implies(implies(Y, X), X)).
+cnf(or_def, axiom, or(X, Y) = implies(not(X), Y)).
+cnf(conjecture, negated_conjecture, or(a,or(b,c)) != or(or(a,b),c)).
diff --git a/tests/minus.p b/tests/minus.p
new file mode 100644
--- /dev/null
+++ b/tests/minus.p
@@ -0,0 +1,12 @@
+cnf(plus_zero, axiom,
+	'+'('0', X) = X).
+cnf(plus_zero, axiom,
+	'+'(X, '0') = X).
+cnf(minus_minus, axiom,
+	'-'('-'(X)) = X).
+cnf(minus_plus, axiom,
+	'-'('+'(X, Y)) = '+'('-'(X), '-'(Y))).
+
+cnf(goal, conjecture,
+    '-'('0') = '0').
+	%% ?[Y]: d(Y) = '+'(x, x)).
diff --git a/tests/nand.p b/tests/nand.p
new file mode 100644
--- /dev/null
+++ b/tests/nand.p
@@ -0,0 +1,37 @@
+%--------------------------------------------------------------------------
+% File     : LAT071-1 : TPTP v6.2.0. Released v2.6.0.
+% Domain   : Lattice Theory (Orthomodularlattices)
+% Problem  : Given single axiom OML-21C, prove associativity
+% Version  : [MRV03] (equality) axioms.
+% English  : Given a single axiom candidate OML-21C for orthomodular lattices
+%            (OML) in terms of the Sheffer Stroke, prove a Sheffer stroke form
+%            of associativity.
+
+% Refs     : [MRV03] McCune et al. (2003), Sheffer Stroke Bases for Ortholatt
+% Source   : [MRV03]
+% Names    : OML-21C-associativity [MRV03]
+
+% Status   : Open
+% Rating   : 1.00 v2.6.0
+% Syntax   : Number of clauses     :    2 (   0 non-Horn;   2 unit;   1 RR)
+%            Number of atoms       :    2 (   2 equality)
+%            Maximal clause size   :    1 (   1 average)
+%            Number of predicates  :    1 (   0 propositional; 2-2 arity)
+%            Number of functors    :    4 (   3 constant; 0-2 arity)
+%            Number of variables   :    4 (   2 singleton)
+%            Maximal term depth    :    6 (   4 average)
+% SPC      : CNF_UNK_UEQ
+
+% Comments :
+%--------------------------------------------------------------------------
+%----Single axiom OML-21C
+cnf(oml_21C,axiom,
+    ( f(f(B,A),f(f(f(f(B,A),A),f(C,A)),f(f(A,A),D))) = A )).
+
+cnf(a, axiom, f(z, f(z, z)) = k).
+
+%----Denial of Sheffer stroke associativity
+cnf(associativity,negated_conjecture,
+    (  f(a,f(f(b,c),f(b,c))) != f(c,f(f(b,a),f(b,a))) )).
+
+%--------------------------------------------------------------------------
diff --git a/tests/nicomachus.p b/tests/nicomachus.p
new file mode 100644
--- /dev/null
+++ b/tests/nicomachus.p
@@ -0,0 +1,18 @@
+cnf(plus_comm, axiom, plus(X, Y) = plus(Y, X)).
+cnf(plus_assoc, axiom, plus(X, plus(Y, Z)) = plus(plus(X, Y), Z)).
+cnf(times_comm, axiom, times(X, Y) = times(Y, X)).
+cnf(times_assoc, axiom, times(X, times(Y, Z)) = times(times(X, Y), Z)).
+cnf(plus_zero, axiom, plus(X, zero) = X).
+cnf(times_zero, axiom, times(X, zero) = zero).
+cnf(times_one, axiom, times(X, one) = X).
+cnf(distr, axiom, times(X, plus(Y, Z)) = plus(times(X, Y), times(X, Z))).
+cnf(distr, axiom, times(plus(X, Y), Z) = plus(times(X, Z), times(Y, Z))).
+cnf(plus_s, axiom, plus(s(X), Y) = s(plus(X, Y))).
+cnf(times_s, axiom, times(s(X), Y) = plus(Y, times(X, Y))).
+cnf(sum_zero, axiom, sum(zero) = zero).
+cnf(sum_s, axiom, sum(s(N)) = plus(s(N), sum(N))).
+cnf(cubes_zero, axiom, cubes(zero) = zero).
+cnf(cubes_s, axiom, cubes(s(N)) = plus(times(s(N), times(s(N), s(N))), cubes(N))).
+cnf(plus_sum, axiom, plus(sum(N), sum(N)) = times(N, s(N))).
+cnf(ih, axiom, times(sum(a), sum(a)) = cubes(a)).
+cnf(conjecture, negated_conjecture, times(sum(s(a)), sum(s(a))) != cubes(s(a))).
diff --git a/tests/ring.p b/tests/ring.p
new file mode 100644
--- /dev/null
+++ b/tests/ring.p
@@ -0,0 +1,9 @@
+cnf(plus_comm, axiom, '+'(X, Y) = '+'(Y, X)).
+cnf(plus_assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).
+cnf(plus_zero, axiom, '+'('0', X) = X).
+cnf(plus_inv, axiom, '+'(X, '-'(X)) = '0').
+cnf(times_assoc, axiom, '*'(X, '*'(Y, Z)) = '*'('*'(X, Y), Z)).
+cnf(distrib, axiom, '*'(X, '+'(Y, Z)) = '+'('*'(X, Y), '*'(X, Z))).
+cnf(distrib, axiom, '*'('+'(X, Y), Z) = '+'('*'(X, Z), '*'(Y, Z))).
+cnf(cube, axiom, X = '*'(X, '*'(X, X))).
+cnf(conjecture, negated_conjecture, '*'(a, b) != '*'(b, a)).
diff --git a/tests/ring2.p b/tests/ring2.p
new file mode 100644
--- /dev/null
+++ b/tests/ring2.p
@@ -0,0 +1,9 @@
+cnf(plus_comm, axiom, '+'(X, Y) = '+'(Y, X)).
+cnf(plus_assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).
+cnf(plus_zero, axiom, '+'('0', X) = X).
+cnf(plus_inv, axiom, '+'(X, '-'(X)) = '0').
+cnf(times_assoc, axiom, '*'(X, '*'(Y, Z)) = '*'('*'(X, Y), Z)).
+cnf(distrib, axiom, '*'(X, '+'(Y, Z)) = '+'('*'(X, Y), '*'(X, Z))).
+cnf(distrib, axiom, '*'('+'(X, Y), Z) = '+'('*'(X, Z), '*'(Y, Z))).
+cnf(power_six, axiom, X = '*'(X, '*'(X, '*'(X, '*'(X, '*'(X, X)))))).
+cnf(conjecture, negated_conjecture, '*'(a, b) != '*'(b, a)).
diff --git a/tests/ring3.p b/tests/ring3.p
new file mode 100644
--- /dev/null
+++ b/tests/ring3.p
@@ -0,0 +1,9 @@
+cnf(plus_comm, axiom, '+'(X, Y) = '+'(Y, X)).
+cnf(plus_assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).
+cnf(plus_zero, axiom, '+'('0', X) = X).
+cnf(plus_neg, axiom, '+'(X, '-'(X)) = '0').
+cnf(times_assoc, axiom, '*'(X, '*'(Y, Z)) = '*'('*'(X, Y), Z)).
+cnf(distrib, axiom, '*'(X, '+'(Y, Z)) = '+'('*'(X, Y), '*'(X, Z))).
+cnf(distrib, axiom, '*'('+'(X, Y), Z) = '+'('*'(X, Z), '*'(Y, Z))).
+cnf(power_four, axiom, X = '*'(X, '*'(X, '*'(X, X)))).
+cnf(conjecture, negated_conjecture, '*'(a, b) != '*'(b, a)).
diff --git a/tests/ring4.p b/tests/ring4.p
new file mode 100644
--- /dev/null
+++ b/tests/ring4.p
@@ -0,0 +1,9 @@
+cnf(plus_comm, axiom, '+'(X, Y) = '+'(Y, X)).
+cnf(plus_assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).
+cnf(plus_zero, axiom, '+'('0', X) = X).
+cnf(plus_inv, axiom, '+'(X, '-'(X)) = '0').
+cnf(times_ssoc, axiom, '*'(X, '*'(Y, Z)) = '*'('*'(X, Y), Z)).
+cnf(distrib, axiom, '*'(X, '+'(Y, Z)) = '+'('*'(X, Y), '*'(X, Z))).
+cnf(distrib, axiom, '*'('+'(X, Y), Z) = '+'('*'(X, Z), '*'(Y, Z))).
+cnf(power_five, axiom, X = '*'(X, '*'(X, '*'(X, '*'(X, X))))).
+cnf(conjecture, negated_conjecture, '*'(a, b) != '*'(b, a)).
diff --git a/tests/robbins-easy.p b/tests/robbins-easy.p
new file mode 100644
--- /dev/null
+++ b/tests/robbins-easy.p
@@ -0,0 +1,4 @@
+cnf(comm, axiom, '+'(X, Y) = '+'(Y, X)).
+cnf(assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).
+cnf(funny, axiom, '+'('-'('+'('-'(X), Y)), '-'('+'('-'(X), '-'(Y)))) = X).
+cnf(conjecture, negated_conjecture, '-'('+'('-'('+'(a, b)), '-'('+'(a, '-'(b))))) != a).
diff --git a/tests/robbins.p b/tests/robbins.p
new file mode 100644
--- /dev/null
+++ b/tests/robbins.p
@@ -0,0 +1,4 @@
+cnf(comm, axiom, '+'(X, Y) = '+'(Y, X)).
+cnf(assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).
+cnf(funny, axiom, '-'('+'('-'('+'(X, Y)), '-'('+'(X, '-'(Y))))) = X).
+cnf(conjecture, negated_conjecture, '-'('-'(a)) != a).
diff --git a/tests/sam.p b/tests/sam.p
new file mode 100644
--- /dev/null
+++ b/tests/sam.p
@@ -0,0 +1,38 @@
+cnf(f_assoc, axiom,
+    meet(X,meet(Y,Z)) = meet(meet(X,Y),Z)).
+cnf(f_comm, axiom,
+    meet(X,Y) = meet(Y,X)).
+cnf(f_idem, axiom,
+    meet(X,X) = X).
+cnf(g_assoc, axiom,
+    join(X,join(Y,Z)) = join(join(X,Y),Z)).
+cnf(g_comm, axiom,
+    join(X,Y) = join(Y,X)).
+cnf(g_idem, axiom,
+    join(X,X) = X).
+
+cnf(ax31, axiom,
+    meet(X, join(X,Y)) = X).
+cnf(ax32, axiom,
+    meet(zero, X) = zero).
+cnf(ax33, axiom,
+    join(zero, X) = X).
+cnf(ax34, axiom,
+    join(X, meet(X, Y)) = X).
+cnf(ax35, axiom,
+    meet(one, X) = X).
+cnf(ax36, axiom,
+    join(one, X) = one).
+cnf(ax37, axiom,
+    meet(X,Z) = X =>
+    meet(join(X,Y),Z) = join(X,meet(Y,Z))).
+
+cnf(comp, definition,
+    comp(X,Y) <=> (meet(X,Y) = zero & join(X,Y) = one)).
+
+cnf(premise1, assumption,
+    comp(a, join(c,d))).
+cnf(premise2, assumption,
+    comp(b, join(c,d))).
+cnf(goal, conjecture,
+    meet(join(a,meet(b,c)),join(a,meet(b,d)))=a).
diff --git a/tests/semigroup.p b/tests/semigroup.p
new file mode 100644
--- /dev/null
+++ b/tests/semigroup.p
@@ -0,0 +1,4 @@
+cnf(assoc, axiom, '*'(X, '*'(Y, Z)) = '*'('*'(X, Y), Z)).
+cnf(two_three, axiom, '*'(X, X) = '*'(X, '*'(X, X))).
+cnf(twiddle, axiom, '*'('*'(X, X), Y) = '*'(Y, '*'(X, X))).
+cnf(conjecture, negated_conjecture, '*'('*'(a, b), '*'(a, b)) != '*'('*'(a, a), '*'(b, b))).
diff --git a/tests/semigroup2.p b/tests/semigroup2.p
new file mode 100644
--- /dev/null
+++ b/tests/semigroup2.p
@@ -0,0 +1,26 @@
+% File     : GRP196-1 : TPTP v6.1.0. Released v2.2.0.
+% Domain   : Group Theory (Semigroups)
+% Problem  : In semigroups, xyyy=yyyx -> (uy)^9 = u^9v^9.
+% Version  : [MP96] (equality) axioms.
+% English  :
+% Refs     : [McC98] McCune (1998), Email to G. Sutcliffe
+%          : [MP96]  McCune & Padmanabhan (1996), Automated Deduction in Eq
+%          : [McC95] McCune (1995), Four Challenge Problems in Equational L
+% Source   : [McC98]
+% Names    : CS-3 [MP96]
+%          : Problem B [McC95]
+% Status   : Unsatisfiable
+% Rating   : 1.00 v4.0.1, 0.93 v4.0.0, 0.92 v3.7.0, 0.89 v3.4.0, 1.00 v3.3.0, 0.93 v3.1.0, 1.00 v2.2.1
+% Syntax   : Number of clauses     :    3 (   0 non-Horn;   3 unit;   1 RR)
+%            Number of atoms       :    3 (   3 equality)
+%            Maximal clause size   :    1 (   1 average)
+%            Number of predicates  :    1 (   0 propositional; 2-2 arity)
+%            Number of functors    :    3 (   2 constant; 0-2 arity)
+%            Number of variables   :    5 (   0 singleton)
+%            Maximal term depth    :   18 (   8 average)
+% SPC      : CNF_UNS_RFO_PEQ_UEQ
+% Comments : The problem was originally posed for cancellative semigroups,
+%            Otter does this with a nonstandard representation [MP96].
+cnf(assoc, axiom, '*'('*'(A,B),C)='*'(A,'*'(B,C))).
+cnf(twiddle, axiom, '*'(A,'*'(B,'*'(B,B)))='*'(B,'*'(B,'*'(B,A)))).
+cnf(conjecture, negated_conjecture, '*'(a,'*'(b,'*'(a,'*'(b,'*'(a,'*'(b,'*'(a,'*'(b,'*'(a,'*'(b,'*'(a,'*'(b,'*'(a,'*'(b,'*'(a,'*'(b,'*'(a,b))))))))))))))))) != '*'(a,'*'(a,'*'(a,'*'(a,'*'(a,'*'(a,'*'(a,'*'(a,'*'(a,'*'(b,'*'(b,'*'(b,'*'(b,'*'(b,'*'(b,'*'(b,'*'(b,b)))))))))))))))))).
diff --git a/tests/veroff.p b/tests/veroff.p
new file mode 100644
--- /dev/null
+++ b/tests/veroff.p
@@ -0,0 +1,10 @@
+cnf(majority, axiom,
+    f(X,X,Y) = X).
+cnf('2a', axiom,
+    f(X,Y,Z) = f(Z,X,Y)).
+cnf('2b', axiom,
+    f(X,Y,Z) = f(X,Z,Y)).
+cnf(associativity, axiom,
+    f(f(X,W,Y),W,Z) = f(X,W,f(Y,W,Z))).
+
+cnf(goal, axiom, f(f(a1,a2,a3),a4,a5) != f(f(a1,a4,a5),f(a2,a4,a5),f(a3,a4,a5))).
diff --git a/tests/winkler-easy.p b/tests/winkler-easy.p
new file mode 100644
--- /dev/null
+++ b/tests/winkler-easy.p
@@ -0,0 +1,6 @@
+% Needs case split on X < c.
+cnf(comm, axiom, '+'(X, Y) = '+'(Y, X)).
+cnf(assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).
+cnf(idem, axiom, '+'(X, X) = X).
+cnf(funny, axiom, '-'('+'('-'('+'(X, Y)), '-'('+'(X, '-'(Y))))) = X).
+cnf(conjecture, negated_conjecture, '+'('-'('+'('-'(a), b)), '-'('+'('-'(a), '-'(b)))) != a).
diff --git a/tests/winkler.p b/tests/winkler.p
new file mode 100644
--- /dev/null
+++ b/tests/winkler.p
@@ -0,0 +1,6 @@
+% Needs case split on X < c.
+cnf(comm, axiom, '+'(X, Y) = '+'(Y, X)).
+cnf(assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).
+cnf(idem_c, axiom, '+'(c, c) = c).
+cnf(funny, axiom, '-'('+'('-'('+'(X, Y)), '-'('+'(X, '-'(Y))))) = X).
+cnf(conjecture, negated_conjecture, '+'('-'('+'('-'(a), b)), '-'('+'('-'(a), '-'(b)))) != a).
diff --git a/tests/winkler2.p b/tests/winkler2.p
new file mode 100644
--- /dev/null
+++ b/tests/winkler2.p
@@ -0,0 +1,6 @@
+% Needs case split on X < c.
+cnf(comm, axiom, '+'(X, Y) = '+'(Y, X)).
+cnf(assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).
+cnf(plus_c_d, axiom, '+'(c, d) = c).
+cnf(funny, axiom, '-'('+'('-'('+'(X, Y)), '-'('+'(X, '-'(Y))))) = X).
+cnf(conjecture, negated_conjecture, '+'('-'('+'('-'(a), b)), '-'('+'('-'(a), '-'(b)))) != a).
diff --git a/tests/y.p b/tests/y.p
new file mode 100644
--- /dev/null
+++ b/tests/y.p
@@ -0,0 +1,3 @@
+fof(k_def, axiom, ![X, Y]: '@'('@'(k, X), Y) = X).
+fof(s_def, axiom, ![X, Y, Z]: '@'('@'('@'(s, X), Y), Z) = '@'('@'(X, Z), '@'(Y, Z))).
+fof(conjecture, conjecture, ?[Y]: ![F]: '@'(Y, F) = '@'(F, '@'(Y, F))).
diff --git a/twee.cabal b/twee.cabal
--- a/twee.cabal
+++ b/twee.cabal
@@ -1,5 +1,5 @@
 name:                twee
-version:             2.1
+version:             2.1.1
 synopsis:            An equational theorem prover
 homepage:            http://github.com/nick8325/twee
 license:             BSD3
@@ -9,7 +9,7 @@
 category:            Theorem Provers
 build-type:          Simple
 cabal-version:       >=1.10
-extra-source-files:  misc/static-libstdc++
+extra-source-files:  README.md tests/*.p misc/*.hs misc/*.pl misc/static-libstdc++
 description:
    Twee is an experimental equational theorem prover based on
    Knuth-Bendix completion.
@@ -41,10 +41,10 @@
   default: False
 
 executable twee
-  main-is:             Main.hs
+  main-is:             executable/Main.hs
   default-language:    Haskell2010
   build-depends:       base < 5,
-                       twee-lib == 2.1,
+                       twee-lib == 2.1.1,
                        containers,
                        pretty,
                        split,