diff --git a/src/TPDB/CPF/Proof/Read.hs b/src/TPDB/CPF/Proof/Read.hs --- a/src/TPDB/CPF/Proof/Read.hs +++ b/src/TPDB/CPF/Proof/Read.hs @@ -2,7 +2,7 @@ module TPDB.CPF.Proof.Read where -import TPDB.CPF.Proof.Type +import TPDB.CPF.Proof.Type as Type import TPDB.Data {- @@ -86,7 +86,6 @@ , csymbols = cs } -getSymbol = element1 "name" &/ \ c -> mk 0 <$> content c getComplexityInput = element "input" >=> \ c -> do trsI <- c $/ element "complexityInput" &/ element "trsInput" &/ getTrsInput @@ -107,14 +106,14 @@ getTrsInput c = - ( c $/ element "trs" &/ getRulesWith Strict ) - <> ( c $/ element "relativeRules" &/ getRulesWith Weak ) + ( c $/ element "trs" &/ getRulesWith TPDB.Data.Strict ) + <> ( c $/ element "relativeRules" &/ getRulesWith TPDB.Data.Weak ) getRulesWith s = element1 "rules" >=> \ c -> return ( c $/ ( element "rule" >=> getRule s ) ) -getRule :: Relation -> Cursor -> [ Rule (Term Identifier Identifier) ] +getRule :: Relation -> Cursor -> [ Rule (Term Identifier Symbol) ] getRule s c = ( \ l r -> Rule {lhs=l,relation=s,rhs=r,top=False}) <$> (c $/ element "lhs" &/ getTerm) <*> (c $/ element "rhs" &/ getTerm) @@ -132,16 +131,19 @@ getDummy :: X.Name -> b -> Cursor -> [ b ] getDummy t c cursor = cursor $| element t >=> return [ c] -getTerm :: Cursor -> [ Term Identifier Identifier ] +getTerm :: Cursor -> [ Term Identifier Symbol ] getTerm = getVar <> getFunApp -getVar :: Cursor -> [ Term Identifier Identifier ] +getVar :: Cursor -> [ Term Identifier Symbol ] getVar = element "var" &/ \ c -> ( Var . mk 0 ) <$> content c -getFunApp :: Cursor -> [ Term Identifier Identifier ] +getFunApp :: Cursor -> [ Term Identifier Symbol ] getFunApp = element "funapp" >=> \ c -> do - nm <- c $/ element "name" &/ content + f <- c $/ getSymbol let args = c $/ element "arg" &/ getTerm - f = mk (length args) $ nm + set_arity k s = mk k $ TPDB.Data.name s -- FIXME return $ Node f args - + + +getSymbol :: Cursor -> [ Symbol ] +getSymbol = element1 "name" &/ \ c -> (SymName . mk 0) <$> content c diff --git a/src/TPDB/CPF/Proof/Type.hs b/src/TPDB/CPF/Proof/Type.hs --- a/src/TPDB/CPF/Proof/Type.hs +++ b/src/TPDB/CPF/Proof/Type.hs @@ -1,7 +1,10 @@ {-# language StandaloneDeriving #-} +{-# language DataKinds, KindSignatures, GADTs, StandaloneDeriving #-} {-# language ExistentialQuantification #-} -{-# language DeriveDataTypeable #-} +{-# language DeriveDataTypeable, DeriveGeneric #-} {-# language OverloadedStrings #-} +{-# language FlexibleContexts #-} +{-# language StrictData #-} -- | internal representation of CPF termination proofs, -- see @@ -21,6 +24,10 @@ import TPDB.Pretty import Data.Text import TPDB.Xml (XmlContent) +import GHC.Generics +import Data.Hashable +import Data.Kind +import qualified Data.Text.Lazy as T data CertificationProblem = CertificationProblem { input :: CertificationProblemInput @@ -28,32 +35,37 @@ , proof :: Proof , origin :: Origin } - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Generic ) data Origin = ProofOrigin { tool :: Tool } - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Generic ) ignoredOrigin = ProofOrigin { tool = Tool "ignored" "ignored" } data Tool = Tool { name :: Text , version :: Text } - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Generic ) +-- | use this type throughout. +-- Variables are plain identifiers +-- but signature can use sharped, and labelled symbols. +type Trs = TRS Identifier Symbol + data CertificationProblemInput - = TrsInput { trsinput_trs :: TRS Identifier Identifier } + = TrsInput { trsinput_trs :: Trs } -- ^ this is actually not true, since instead of copying from XTC, -- CPF format repeats the definition of TRS, -- and it's a different one (relative rules are extra) - | ComplexityInput { trsinput_trs :: TRS Identifier Identifier + | ComplexityInput { trsinput_trs :: Trs , complexityMeasure :: ComplexityMeasure , complexityClass :: ComplexityClass } - | ACRewriteSystem { trsinput_trs :: TRS Identifier Identifier - , asymbols :: [ Identifier ] - , csymbols :: [ Identifier ] + | ACRewriteSystem { trsinput_trs :: Trs + , asymbols :: [ Symbol ] + , csymbols :: [ Symbol ] } - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Generic ) instance Pretty CertificationProblemInput where pretty cpi = case cpi of @@ -72,91 +84,131 @@ , "csymbols" <+> text (show $ csymbols cpi ) ] -data Proof = TrsTerminationProof TrsTerminationProof - | TrsNonterminationProof TrsNonterminationProof - | RelativeTerminationProof TrsTerminationProof - | RelativeNonterminationProof TrsNonterminationProof +data Kind = Standard | Relative + deriving ( Typeable, Eq, Generic ) + +data Proof = TrsTerminationProof (TrsTerminationProof Standard) + | TrsNonterminationProof (TrsNonterminationProof Standard) + | RelativeTerminationProof (TrsTerminationProof Relative) + | RelativeNonterminationProof (TrsNonterminationProof Relative) | ComplexityProof ComplexityProof | ACTerminationProof ACTerminationProof - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Generic ) -data DPS = forall s . ( XmlContent s , - Typeable s, Eq s ) - => DPS [ Rule (Term Identifier s) ] +data DPS = DPS [ Rule (Term Identifier Symbol) ] deriving ( Typeable ) instance Eq DPS where x == y = error "instance Eq DPS" data ComplexityProof = ComplexityProofFIXME () - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Generic ) data ComplexityMeasure = DerivationalComplexity | RuntimeComplexity - deriving ( Typeable, Eq, Show ) + deriving ( Typeable, Eq, Generic , Show ) data ComplexityClass = ComplexityClassPolynomial { degree :: Int } -- ^ it seems the degree must always be given in CPF, -- although the category spec also allows "POLY" -- http://cl-informatik.uibk.ac.at/users/georg/cbr/competition/rules.php - deriving ( Typeable, Eq, Show ) + deriving ( Typeable, Eq, Generic , Show ) -data TrsNonterminationProof = TrsNonterminationProofFIXME () - deriving ( Typeable, Eq ) +data TrsNonterminationProof (k :: Kind) + = VariableConditionViolated + | TNP_RuleRemoval Trs (TrsNonterminationProof k) + | TNP_StringReversal Trs (TrsNonterminationProof k) + | Loop + { rewriteSequence :: RewriteSequence + , substitution :: Substitution + , context :: Context + } + deriving ( Typeable, Eq, Generic ) -data TrsTerminationProof - = RIsEmpty - | RuleRemoval { rr_orderingConstraintProof :: OrderingConstraintProof - , trs :: TRS Identifier Identifier - , trsTerminationProof :: TrsTerminationProof - } - | DpTrans { dptrans_dps :: DPS - , markedSymbols :: Bool , dptrans_dpProof :: DpProof } - | Semlab { model :: Model - , trs :: TRS Identifier Identifier - , trsTerminationProof :: TrsTerminationProof - } - | Unlab { trs :: TRS Identifier Identifier - , trsTerminationProof :: TrsTerminationProof - } - | StringReversal { trs :: TRS Identifier Identifier - , trsTerminationProof :: TrsTerminationProof - } - | Bounds { trs :: TRS Identifier Identifier - , bounds_type :: Bounds_Type +data RewriteSequence = RewriteSequence (Term Identifier Symbol) [ RewriteStep ] + deriving ( Typeable, Eq, Generic ) + +data RewriteStep = RewriteStep + { rs_position :: Position + , rs_rule :: Rule (Term Identifier Symbol) + , rs_term :: Term Identifier Symbol + } + deriving ( Typeable, Eq, Generic ) + +data Substitution = Substitution [ SubstEntry ] + deriving ( Typeable, Eq, Generic ) + +data SubstEntry = SubstEntry Identifier (Term Identifier Symbol) + deriving ( Typeable, Eq, Generic ) + +data Context = Box + | FunContext { fc_symbol :: Symbol + , fc_before :: [Term Identifier Symbol ] + , fc_here :: Context + , fc_after :: [Term Identifier Symbol ] + } + deriving ( Typeable, Eq, Generic ) + +data TrsTerminationProof (k :: Kind) where + RIsEmpty :: TrsTerminationProof k + SIsEmpty :: { trsTerminationProof_Standard :: !(TrsTerminationProof Standard) } + -> TrsTerminationProof Relative + RuleRemoval :: { rr_orderingConstraintProof :: !OrderingConstraintProof + , trs :: !Trs + , trsTerminationProof :: !(TrsTerminationProof k) + } -> TrsTerminationProof k + EqualityRemoval :: { trsTerminationProof_Relative :: !(TrsTerminationProof Relative) + } -> TrsTerminationProof Relative + DpTrans :: { dptrans_dps :: DPS + , markedSymbols :: Bool , dptrans_dpProof :: DpProof } -> TrsTerminationProof Standard + FlatContextClosure :: + { flatContexts :: ![Context] + , trs :: !Trs + , trsTerminationProof :: !(TrsTerminationProof k) + } -> TrsTerminationProof k + Semlab :: { model :: !Model + , trs :: !Trs + , trsTerminationProof :: !(TrsTerminationProof k) + } -> TrsTerminationProof k + Split :: { trs :: !Trs + , remove :: !(TrsTerminationProof Relative) + , remain :: !(TrsTerminationProof k) + } -> TrsTerminationProof k + StringReversal :: { trs :: !Trs + , trsTerminationProof :: !(TrsTerminationProof k) + } -> TrsTerminationProof k + Bounds :: { bounds_type :: Bounds_Type , bounds_bound :: Int , bounds_finalStates :: [ State ] - , bounds_closedTreeAutomaton :: ClosedTreeAutomaton - } - deriving ( Typeable, Eq ) + , bounds_closedTreeAutomaton :: TreeAutomaton + , bounds_criterion :: Criterion + } -> TrsTerminationProof Standard -data Bounds_Type = Roof | Match - deriving ( Typeable, Eq ) +deriving instance Typeable (TrsTerminationProof k) +deriving instance Eq (TrsTerminationProof k) +-- deriving instance Generic (TrsTerminationProof k) -data ClosedTreeAutomaton = ClosedTreeAutomaton - { cta_treeAutomaton :: TreeAutomaton - , cta_criterion :: Criterion - } - deriving ( Typeable, Eq ) +data Bounds_Type = Roof | Match + deriving ( Typeable, Eq, Generic ) data Criterion = Compatibility - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Generic ) data TreeAutomaton = TreeAutomaton { ta_finalStates :: [ State ] , ta_transitions :: [ Transition ] } - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Generic ) -data State = State Int - deriving ( Typeable, Eq ) +data State = State Text -- Int -- Ha! Wrong. + deriving ( Typeable, Eq, Generic ) data Transition = Transition { transition_lhs :: Transition_Lhs - , transition_rhs :: [ State ] + , transition_rhs :: State } - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Generic ) data Transition_Lhs = Transition_Symbol { tr_symbol :: Symbol @@ -164,17 +216,24 @@ , tr_arguments :: [ State ] } | Transition_Epsilon State - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Generic ) -data Model = FiniteModel Int [Interpret] - deriving ( Typeable, Eq ) - +data Model + = FiniteModel Int [Interpret] + | RootLabeling + deriving ( Typeable, Eq, Generic ) + +data Mono = Weak | Strict + deriving ( Typeable, Eq, Generic ) + data DpProof = PIsEmpty - | RedPairProc { rppOrderingConstraintProof :: OrderingConstraintProof - , rppDps :: DPS + | RedPairProc { rppMono :: Mono + , rppOrderingConstraintProof :: OrderingConstraintProof + , rppDps :: DPS + , rppTrs :: Maybe Trs , rppUsableRules :: Maybe DPS , rppDpProof :: DpProof - } + } | DepGraphProc [ DepGraphComponent ] | SemLabProc { slpModel :: Model @@ -186,53 +245,53 @@ , ulpTrs :: DPS , ulpDpProof :: DpProof } - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Generic ) data DepGraphComponent = DepGraphComponent { dgcRealScc :: Bool , dgcDps :: DPS , dgcDpProof :: DpProof } - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Generic ) data OrderingConstraintProof = OCPRedPair RedPair - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Generic ) data RedPair = RPInterpretation Interpretation | RPPathOrder PathOrder - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Generic ) data Interpretation = Interpretation { interpretation_type :: Interpretation_Type , interprets :: [ Interpret ] } - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Generic ) data Interpretation_Type = Matrix_Interpretation { domain :: Domain, dimension :: Int , strictDimension :: Int } - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Generic ) data Domain = Naturals | Rationals Rational | Arctic Domain | Tropical Domain - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Generic ) data Interpret = Interpret { symbol :: Symbol , arity :: Int , value :: Value } - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Generic ) data Value = Polynomial Polynomial | ArithFunction ArithFunction - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Generic ) data Polynomial = Sum [ Polynomial ] | Product [ Polynomial ] | Polynomial_Coefficient Coefficient | Polynomial_Variable Text - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Generic ) data ArithFunction = AFNatural Integer | AFVariable Integer @@ -241,46 +300,61 @@ | AFMin [ArithFunction] | AFMax [ArithFunction] | AFIfEqual ArithFunction ArithFunction ArithFunction ArithFunction - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Generic ) data Symbol = SymName Identifier | SymSharp Symbol | SymLabel Symbol Label - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Ord, Generic ) +instance Hashable Symbol +instance Pretty Symbol where + pretty s = case s of + SymName n -> pretty n + SymSharp s -> pretty s <> "#" + SymLabel s l -> pretty s <> "_" <> pretty l + +instance Show Symbol where show = T.unpack . render . pretty + + data Label = LblNumber [Integer] | LblSymbol [Symbol] - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Ord, Generic ) +instance Hashable Label +instance Pretty Label where + pretty (LblNumber xs) = pretty xs + pretty (LblSymbol xs) = pretty xs + data Coefficient = Vector [ Coefficient ] | Matrix [ Coefficient ] | forall a . (Eq a , XmlContent a ) => Coefficient_Coefficient a deriving ( Typeable ) -instance Eq Coefficient where x == y = error "instance Eq Coefficient" +instance Eq Coefficient where + x == y = error "instance Eq Coefficient" data Exotic = Minus_Infinite | E_Integer Integer | E_Rational Rational | Plus_Infinite - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Generic ) class ToExotic a where toExotic :: a -> Exotic data PathOrder = PathOrder [PrecedenceEntry] [ArgumentFilterEntry] - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Generic ) data PrecedenceEntry = PrecedenceEntry { peSymbol :: Symbol , peArity :: Int , pePrecedence :: Integer } - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Generic ) data ArgumentFilterEntry = ArgumentFilterEntry { afeSymbol :: Symbol , afeArity :: Int , afeFilter :: Either Int [Int] } - deriving ( Typeable, Eq ) + deriving ( Typeable, Eq, Generic ) data ACTerminationProof = ACTerminationProofFIXME () - deriving ( Typeable, Eq ) - + deriving ( Typeable, Eq, Generic ) diff --git a/src/TPDB/CPF/Proof/Util.hs b/src/TPDB/CPF/Proof/Util.hs --- a/src/TPDB/CPF/Proof/Util.hs +++ b/src/TPDB/CPF/Proof/Util.hs @@ -1,4 +1,6 @@ {-# LANGUAGE LambdaCase #-} +{-# LANGUAGE FlexibleContexts #-} + module TPDB.CPF.Proof.Util where import qualified Data.Map as M @@ -7,13 +9,14 @@ import TPDB.CPF.Proof.Type hiding (name) import TPDB.DP import Data.String (fromString) +import Data.Hashable fromMarkedIdentifier :: Marked Identifier -> Symbol fromMarkedIdentifier = \case Original i -> SymName i Marked i -> SymSharp $ SymName i -sortVariables :: Rule (Term Identifier s) -> Rule (Term Identifier s) +sortVariables :: (Ord s, Hashable s) => Rule (Term Identifier s) -> Rule (Term Identifier s) sortVariables r = r { lhs = vmap mapVar $ lhs r , rhs = vmap mapVar $ rhs r } diff --git a/src/TPDB/CPF/Proof/Write.hs b/src/TPDB/CPF/Proof/Write.hs --- a/src/TPDB/CPF/Proof/Write.hs +++ b/src/TPDB/CPF/Proof/Write.hs @@ -1,15 +1,18 @@ -{-# language TypeSynonymInstances, FlexibleContexts, FlexibleInstances, UndecidableInstances, OverlappingInstances, IncoherentInstances, PatternSignatures, DeriveDataTypeable, OverloadedStrings #-} +{-# language TypeSynonymInstances, FlexibleContexts, FlexibleInstances, UndecidableInstances, OverlappingInstances, IncoherentInstances, PatternSignatures, DeriveDataTypeable, OverloadedStrings, LambdaCase, DataKinds, GADTs, QuasiQuotes #-} +{-# OPTIONS_GHC -Werror=incomplete-patterns #-} + -- | from internal representation to XML, and back module TPDB.CPF.Proof.Write where -import TPDB.CPF.Proof.Type +import TPDB.CPF.Proof.Type as Type import qualified TPDB.Data as T import TPDB.Xml import Text.XML -import TPDB.Data.Xml +import TPDB.Data.Xml +import Text.Hamlet.XML import Data.List ( nub ) import Data.Char ( toLower ) @@ -21,6 +24,7 @@ import Control.Monad import Data.Typeable import Data.Ratio +import Data.String (fromString) tox :: CertificationProblem -> Document tox p = @@ -58,10 +62,11 @@ parseContents = error "parseContents not implemented" toContents i = case i of - TrsInput {} -> rmkel "trsInput" $ toContents ( symbolize $ trsinput_trs i ) + TrsInput {} -> rmkel "trsInput" $ toContents (trsinput_trs i ) ComplexityInput {} -> rmkel "complexityInput" $ concat - [ rmkel "trsInput" $ toContents $ symbolize $ trsinput_trs i + [ rmkel "trsInput" $ toContents $ trsinput_trs i ] + ACRewriteSystem {} -> error "toContents ACRewriteSystem" instance XmlContent ( T.TRS Identifier Symbol ) where parseContents = error "parseContents not implemented" @@ -85,10 +90,11 @@ let missing t = rmkel t $ rmkel "missing-toContents-instance" [] in case p of TrsTerminationProof p -> toContents p - TrsNonterminationProof p -> missing "TrsNonterminationProof" - RelativeTerminationProof p -> missing "RelativeTerminationProof" - RelativeNonterminationProof p -> missing "RelativeNonterminationProof" + TrsNonterminationProof p -> toContents p + RelativeTerminationProof p -> toContents p + RelativeNonterminationProof p -> toContents p ComplexityProof p -> missing "ComplexityProof" + ACTerminationProof p -> missing "ACTerminationProof" instance XmlContent DPS where parseContents = error "parseContents not implemented" @@ -96,7 +102,7 @@ toContents ( DPS rules ) = rmkel "dps" $ rmkel "rules" $ rules >>= toContents -instance XmlContent TrsTerminationProof where +instance XmlContent (TrsTerminationProof Standard) where parseContents = error "parseContents not implemented" toContents p = rmkel "trsTerminationProof" $ case p of @@ -107,25 +113,85 @@ , toContents $ dptrans_dpProof p ] StringReversal {} -> rmkel "stringReversal" $ concat - [ toContents $ symbolize $ trs p + [ toContents $ trs p , toContents $ trsTerminationProof p ] + FlatContextClosure {} -> rmkel "flatContextClosure" $ concat + [ rmkel "flatContexts" $ concatMap toContents + $ flatContexts p + , toContents $ trs p + , toContents $ trsTerminationProof p + ] + Semlab {} -> rmkel "semlab" $ concat + [ toContents $ model p + , toContents $ trs p + , toContents $ trsTerminationProof p + ] + Split {} -> rmkel "split" $ concat + [ toContents $ trs p + , toContents $ remove p + , toContents $ remain p + ] RuleRemoval {} -> rmkel "ruleRemoval" $ concat [ toContents $ rr_orderingConstraintProof p - , toContents $ symbolize $ trs p + , toContents $ trs p , toContents $ trsTerminationProof p ] Bounds {} -> rmkel "bounds" $ concat - [ toContents $ symbolize $ trs p - , toContents $ bounds_type p + [ rmkel "type" $ toContents $ bounds_type p , rmkel "bound" $ toContents $ bounds_bound p , rmkel "finalStates" $ concat $ map toContents $ bounds_finalStates p , toContents $ bounds_closedTreeAutomaton p + , rmkel "criterion" $ toContents $ bounds_criterion p ] +instance XmlContent (TrsTerminationProof Relative) where + parseContents = error "parseContents not implemented" + + toContents p = rmkel "relativeTerminationProof" $ case p of + RIsEmpty -> rmkel "rIsEmpty" [] + SIsEmpty {} -> rmkel "sIsEmpty" $ concat + [ toContents $ trsTerminationProof_Standard p + ] + StringReversal {} -> rmkel "stringReversal" $ concat + [ toContents $ standard $ trs p + , toContents $ relative $ trs p + , toContents $ trsTerminationProof p + ] + FlatContextClosure {} -> rmkel "flatContextClosure" $ concat + [ rmkel "flatContexts" $ concatMap toContents + $ flatContexts p + , toContents $ standard $ trs p + , toContents $ relative $ trs p + , toContents $ trsTerminationProof p + ] + Semlab {} -> rmkel "semlab" $ concat + [ toContents $ model p + , toContents $ standard $ trs p + , toContents $ relative $ trs p + , toContents $ trsTerminationProof p + ] + RuleRemoval {} -> rmkel "ruleRemoval" $ concat + [ toContents $ rr_orderingConstraintProof p + , toContents $ standard $ trs p + , toContents $ relative $ trs p + , toContents $ trsTerminationProof p + ] + EqualityRemoval {} -> rmkel "equalityRemoval" $ concat + [ toContents $ trsTerminationProof_Relative p + ] + Split {} -> rmkel "split" $ concat + [ toContents $ trs p + , toContents $ remove p + , toContents $ remain p + ] + +standard trs = trs `T.with_rules` filter T.strict (T.rules trs) +relative trs = trs `T.with_rules` filter T.weak (T.rules trs) + symbolize trs = - ( fmap (fmap SymName) trs ) + ( fmap (T.tmap SymName) trs ) { T.signature = map SymName $ T.signature trs } instance XmlContent Bounds_Type where @@ -134,13 +200,8 @@ Match -> rmkel "match" [] instance XmlContent State where - toContents (State s) = rmkel "state" $ toContents s - -instance XmlContent ClosedTreeAutomaton where - toContents c = concat - [ toContents $ cta_treeAutomaton c - , toContents $ cta_criterion c - ] + toContents (State s) = + rmkel "state" [xml|#{fromString $ escape $ T.unpack s}|] instance XmlContent Criterion where toContents c = case c of @@ -157,8 +218,7 @@ instance XmlContent Transition where toContents t = rmkel "transition" $ concat [ rmkel "lhs" $ toContents $ transition_lhs t - , rmkel "rhs" $ concat - $ map toContents $ transition_rhs t + , rmkel "rhs" $ toContents $ transition_rhs t ] instance XmlContent Transition_Lhs where @@ -179,22 +239,29 @@ [ rmkel "carrierSize" $ toContents carrierSize , concatMap toContents interprets ] + RootLabeling -> rmkel "rootLabeling" [] instance XmlContent DpProof where parseContents = error "parseContents not implemented" toContents p = rmkel "dpProof" $ case p of PIsEmpty -> rmkel "pIsEmpty" [] - RedPairProc {} -> case rppUsableRules p of - Nothing -> rmkel "redPairProc" $ concat - [ toContents $ rppOrderingConstraintProof p - , toContents $ rppDps p - , toContents $ rppDpProof p - ] - Just (DPS ur) -> rmkel "redPairUrProc" $ concat + RedPairProc {} -> + let name = case rppUsableRules p of + Nothing -> case rppMono p of + Weak -> "redPairProc"; Strict -> "monoRedPairProc" + Just _ -> case rppMono p of + Weak -> "redPairUrProc"; Strict -> "monoRedPairUrProc" + in rmkel name $ concat [ toContents $ rppOrderingConstraintProof p , toContents $ rppDps p - , rmkel "usableRules" $ rmkel "rules" $ concatMap toContents ur + , case rppTrs p of + Nothing -> [] + Just sys -> toContents sys + , case rppUsableRules p of + Nothing -> [] + Just (DPS ur) -> rmkel "usableRules" + $ rmkel "rules" $ concatMap toContents ur , toContents $ rppDpProof p ] DepGraphProc cs -> rmkel "depGraphProc" $ concat $ map toContents cs @@ -326,6 +393,7 @@ toContents e = case e of Minus_Infinite -> rmkel "minusInfinity" [] E_Integer i -> rmkel "integer" $ toContents i + E_Rational r -> {- rmkel "rational" $ -} toContents r Plus_Infinite -> rmkel "plusInfinity" [] -- see remark in TPDB.Data.Xml (sharp_name_HACK) @@ -376,3 +444,60 @@ Right is -> rmkel "nonCollapsing" $ map (\i -> mkel "position" $ toContents i) is ] + +instance XmlContent (TrsNonterminationProof Standard) where + toContents tnp = rmkel "trsNonterminationProof" $ case tnp of + VariableConditionViolated -> rmkel "variableConditionViolated" [] + TNP_RuleRemoval sys sub -> rmkel "ruleRemoval" + $ concat [ toContents sys, toContents sub ] + TNP_StringReversal sys sub -> rmkel "stringReversal" + $ concat [ toContents sys , toContents sub ] + Loop {rewriteSequence = rs, substitution = sub, context = ctx } -> rmkel "loop" + $ concat [ toContents rs, toContents sub, toContents ctx ] + +instance XmlContent (TrsNonterminationProof Relative) where + toContents tnp = rmkel "relativeNonterminationProof" $ case tnp of + VariableConditionViolated -> rmkel "variableConditionViolated" [] + TNP_RuleRemoval sys sub -> rmkel "ruleRemoval" + $ concat [ toContents sys, toContents sub ] + TNP_StringReversal sys sub -> rmkel "stringReversal" + $ concat [ toContents sys , toContents sub ] + Loop {rewriteSequence = rs, substitution = sub, context = ctx } -> rmkel "loop" + $ concat [ toContents rs, toContents sub, toContents ctx ] + +instance XmlContent RewriteSequence where + toContents (RewriteSequence start steps) = + rmkel "rewriteSequence" $ concat + [ rmkel "startTerm" $ toContents start + , concatMap toContents steps + ] + +instance XmlContent RewriteStep where + toContents rs = rmkel "rewriteStep" $ concat + [ rmkel "positionInTerm" + $ concatMap (\ k -> rmkel "position" $ toContents k ) $ rs_position rs + , toContents $ rs_rule rs + , case T.relation $ rs_rule rs of + T.Strict -> [] + T.Weak -> rmkel "relative" [] + T.Equal -> error "toContents for Equal rule" + , toContents $ rs_term rs + ] + +instance XmlContent Substitution where + toContents (Substitution ses) = rmkel "substitution" $ concatMap toContents ses +instance XmlContent SubstEntry where + toContents (SubstEntry v t) = rmkel "substEntry" $ concat + [ toContents $ (T.Var v :: T.Term Identifier Symbol) + , toContents $ t + ] + +instance XmlContent Context where + toContents c = case c of + Box -> rmkel "box" [] + FunContext {} -> rmkel "funContext" $ concat + [ toContents $ fc_symbol c + , rmkel "before" $ concatMap toContents $ fc_before c + , toContents $ fc_here c + , rmkel "after" $ concatMap toContents $ fc_after c + ] diff --git a/src/TPDB/Convert.hs b/src/TPDB/Convert.hs --- a/src/TPDB/Convert.hs +++ b/src/TPDB/Convert.hs @@ -14,13 +14,15 @@ set_arity a s = s { arity = a } convert_srs_rule u = - let v = mk 0 "x" + let v = case original_variable u of + Nothing -> mk 0 "x" -- RISKY + Just v -> v handle = unspine v . map (set_arity 1) in u { lhs = handle $ lhs u , rhs = handle $ rhs u } -trs2srs :: Eq v => TRS v s -> Maybe ( SRS s ) +trs2srs :: (Eq v, TermC v s, v ~ Identifier) => TRS v s -> Maybe ( SRS s ) trs2srs t = do us <- forM ( rules t ) convert_trs_rule return $ t { separate = True , rules = us } @@ -29,14 +31,17 @@ ( left_spine, left_base ) <- spine $ lhs u ( right_spine, right_base ) <- spine $ rhs u guard $ left_base == right_base - return $ u { lhs = left_spine, rhs = right_spine } + return $ u + { lhs = left_spine, rhs = right_spine + , original_variable = Just left_base + } -unspine :: v -> [s] -> Term v s +unspine :: TermC v s => v -> [s] -> Term v s unspine v = foldr ( \ c t -> Node c [ t ] ) ( Var v ) -- | success iff term consists of unary symbols -- and the lowest node is a variable -spine :: Term v s -> Maybe ( [s], v ) +spine :: TermC v s => Term v s -> Maybe ( [s], v ) spine t = case t of Node f args -> do [ arg ] <- return args diff --git a/src/TPDB/DP/Graph.hs b/src/TPDB/DP/Graph.hs --- a/src/TPDB/DP/Graph.hs +++ b/src/TPDB/DP/Graph.hs @@ -12,8 +12,8 @@ import TPDB.Plain.Read -- for testing import TPDB.Plain.Write -- for testing -import qualified Data.Set as S -import qualified Data.Map as M +import qualified Data.IntSet as S +import qualified Data.IntMap.Strict as M import Data.Graph ( stronglyConnComp, SCC(..) ) import Control.Monad ( guard, forM ) import Control.Applicative @@ -25,29 +25,31 @@ -- topologically sorted, with CyclicComponents in Right, -- others in Left. components s = do - let es = M.fromListWith (++) - $ do (p,q) <- edges s ; return (p, [q]) - key = M.fromList - $ zip (filter strict $ rules s) [0.. ] + let su = indexed s + ns = filter (not . strict) (rules s) + es = M.fromListWith (<>) + $ do (i,j) <- edges su ; return (i, S.singleton j) comp <- reverse $ stronglyConnComp $ do - p <- M.keys key - let qs = M.findWithDefault [] p es - return (p, key M.! p, map (key M.!) qs ) + (i,u) <- M.toList su + let js = M.findWithDefault mempty i es + return (u, i, S.toList js) return $ case comp of - CyclicSCC vs -> Right $ s { rules = vs - ++ filter (not . strict) (rules s) } + CyclicSCC vs -> Right $ s { rules = vs <> ns } AcyclicSCC v -> Left v -- | edges of the estimated dependency graph -edges s = do - let def = S.filter isOriginal $ defined s - u <- filter strict $ rules s - v <- filter strict $ rules s - guard $ unifies ( vmap Left $ tcap s $ rhs u ) +edges su = do + (i,u) <- M.toList su + (j,v) <- M.toList su + guard $ unifies ( vmap Left $ tcap (M.elems su) $ rhs u ) ( vmap Right $ lhs v ) - return (u,v) + return (i,j) -check = edges $ dp sys +check = edges $ indexed $ dp sys + +-- | numbering for non-strict rules +indexed :: TRS v c -> M.IntMap (Rule (Term v c)) +indexed s = M.fromList $ zip [0::Int ..] $ filter strict $ rules s -- example from "DP Revisited" http://colo6-c703.uibk.ac.at/ttt/rta04.pdf Right sys = diff --git a/src/TPDB/DP/TCap.hs b/src/TPDB/DP/TCap.hs --- a/src/TPDB/DP/TCap.hs +++ b/src/TPDB/DP/TCap.hs @@ -1,10 +1,13 @@ -module TPDB.DP.TCap where +{-# language FlexibleContexts #-} +module TPDB.DP.TCap (tcap) where + import TPDB.Data import TPDB.Pretty import TPDB.DP.Unify +import Control.Monad (forM) import Control.Monad.State.Strict import Control.Applicative @@ -13,17 +16,18 @@ -- even if the term is instantiated. All other parts are replaced by fresh variables. -- Def 4.4 in http://cl-informatik.uibk.ac.at/users/griff/publications/Sternagel-Thiemann-RTA10.pdf -tcap :: (Ord v, Ord c) => TRS v c -> Term v c -> Term Int c +tcap :: (Ord v, Eq c, TermC v c) => [Rule (Term v c)] -> Term v c -> Term Int c tcap dp t = evalState ( walk dp t ) 0 -fresh_var :: State Int ( Term Int c ) -fresh_var = do i <- get ; put $ succ i ; return $ Var i +fresh_var :: TermC Int c => State Int ( Term Int c ) +fresh_var = do i <- get ; put $! succ i ; return $ Var i -walk dp t = case t of - Node f args -> do - t' <- Node f <$> forM args (walk dp) - if all ( \ u -> not $ unifies ( vmap Left $ lhs u ) ( vmap Right t' ) ) - $ filter (not . strict) $ rules dp +{-# INLINE walk #-} +walk dp = + let go t = case t of + Node f args -> do + t' <- Node f <$> forM args go + if all ( \ u -> not $ unifies ( vmap Left $ lhs u ) ( vmap Right t' ) ) $ filter (not . strict) dp then return t' else fresh_var - _ -> fresh_var - + _ -> fresh_var + in go diff --git a/src/TPDB/DP/Transform.hs b/src/TPDB/DP/Transform.hs --- a/src/TPDB/DP/Transform.hs +++ b/src/TPDB/DP/Transform.hs @@ -1,7 +1,13 @@ {-# language OverloadedStrings #-} {-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE PatternSynonyms #-} -module TPDB.DP.Transform where +module TPDB.DP.Transform + ( dp, mark, Marked + , pattern Marked, pattern Original, pattern Auxiliary + , isOriginal, isMarked, mark_top + , defined + ) where import TPDB.Data import TPDB.Pretty @@ -12,23 +18,35 @@ import Data.Hashable import GHC.Generics -data Marked a = Original a | Marked a | Auxiliary a +data Mark = Orig + | Mark + | Aux -- ^ wat is this? + deriving (Eq, Ord, Show, Generic) +instance Hashable Mark + +data Marked a = Marked_Imp { contents :: !a + , mark :: !Mark + } deriving ( Show, Eq, Ord, Generic ) -isOriginal m = case m of Original {} -> True ; _ -> False -isMarked m = case m of Marked {} -> True ; _ -> False +pattern Marked a = Marked_Imp { mark = Mark, contents = a } +pattern Original a = Marked_Imp { mark = Orig, contents = a } +pattern Auxiliary a = Marked_Imp { mark = Aux, contents = a } +isOriginal m = mark m == Orig +isMarked m = mark m == Mark + instance Hashable a => Hashable (Marked a) instance Pretty a => Pretty ( Marked a) where - pretty m = case m of - Original a -> pretty a - Marked a -> pretty a <> "#" - Auxiliary a -> pretty a + pretty m = let p = pretty (contents m) in case mark m of + Orig -> p + Mark -> p <> "#" + Aux -> p -mark_top :: Term v a -> Term v (Marked a) +mark_top :: TermC v a => Term v a -> Term v (Marked a) mark_top (Node f args) = - Node (Marked f) $ map (fmap Original) args + Node (Marked f) $ map (tmap Original) args defined s = S.fromList $ do u <- rules s @@ -38,21 +56,23 @@ -- | compute the DP transformed system. -dp :: (Ord v, Ord s) +dp :: (Eq v, Ord s, TermC v s) => RS s (Term v s) -> RS (Marked s) (Term v (Marked s)) dp s = let os = map ( \ u -> Rule { relation = Weak - , lhs = fmap Original $ lhs u - , rhs = fmap Original $ rhs u + , lhs = tmap Original $ lhs u + , rhs = tmap Original $ rhs u , top = False } ) $ rules s def = defined s us = do u <- rules s - let ssubs = S.fromList $ strict_subterms $ lhs u - walk r = if S.member r ssubs then [] else case r of + let -- ssubs = S.fromList $ strict_subterms $ lhs u + walk r = if -- S.member r ssubs + isStrictSubtermOf r (lhs u) + then [] else case r of -- will raise exception if rhs contains -- a variable that is not in lhs Node f args -> diff --git a/src/TPDB/DP/Unify.hs b/src/TPDB/DP/Unify.hs --- a/src/TPDB/DP/Unify.hs +++ b/src/TPDB/DP/Unify.hs @@ -1,7 +1,10 @@ +{-# language FlexibleContexts #-} + module TPDB.DP.Unify ( mgu, match, unifies, apply, times ) where import TPDB.Data -import qualified Data.Map as M +import qualified Data.Map.Strict as M +import qualified Data.Set as S import Control.Monad ( guard, foldM ) import Data.Maybe (isJust) @@ -10,47 +13,55 @@ unifies t1 t2 = isJust $ mgu t1 t2 -- | view variables as symbols -pack :: Term v c -> Term any (Either v c) +pack :: (Ord v, TermC v c, TermC any (Either v c)) + => Term v c -> Term any (Either v c) pack ( Var v ) = Node ( Left v ) [] pack ( Node f args ) = Node ( Right f ) ( map pack args ) -unpack :: Term any (Either v c) -> Term v c +unpack :: (TermC v c, TermC any (Either v c)) + => Term any (Either v c) -> Term v c unpack ( Node ( Left v ) [] ) = Var v unpack ( Node ( Right f ) args ) = Node f ( map unpack args ) -- | will only bind variables in the left side -match :: ( Ord v, Ord w, Eq c ) +match :: ( Ord v, Ord w, Eq c, TermC v c, TermC w c ) => Term v c -> Term w c -> Maybe ( M.Map v ( Term w c ) ) match l r = do - u <- mgu ( fmap Right l ) ( pack r ) + u <- mgu ( tmap Right l ) ( pack r ) return $ M.map unpack u -- | naive implementation (worst case exponential) mgu - :: (Ord v, Eq c) => + :: (Ord v, Eq c, TermC v c) => Term v c -> Term v c -> Maybe (M.Map v (Term v c)) mgu t1 t2 | t1 == t2 = return M.empty mgu ( Var v ) t2 = do + -- this requires t2 to be visited completely: + -- guard $ not $ S.member v $ vars t2 + -- this is lazy: will stop when encountering first v occurence guard $ not $ elem (Var v) $ subterms t2 + -- also lazy, but will allocate the DOUBLE amount of mem: + -- guard $ not $ elem v $ voccs t2 return $ M.singleton v t2 mgu t1 ( Var v ) = mgu ( Var v ) t1 mgu (Node f1 args1) (Node f2 args2) | f1 == f2 && length args1 == length args2 = do - guard $ f1 == f2 foldM ( \ s (l,r) -> do t <- mgu (apply l s) (apply r s) return $ times s t ) M.empty $ zip args1 args2 mgu _ _ = Nothing - -times :: Ord v + +{-# INLINE times #-} +times :: (Ord v, TermC v c) => Substitution v c -> Substitution v c -> Substitution v c times s t = - M.union ( M.difference t s ) - ( M.map ( \ v -> apply v t ) s ) - + M.union ( M.map ( \ v -> apply v t ) s ) + t -- ( M.difference t s ) + +{-# INLINE apply #-} apply t s = case t of Var v -> case M.lookup v s of Nothing -> t ; Just w -> w Node f args -> Node f $ map (\ a -> apply a s) args diff --git a/src/TPDB/DP/Usable.hs b/src/TPDB/DP/Usable.hs --- a/src/TPDB/DP/Usable.hs +++ b/src/TPDB/DP/Usable.hs @@ -6,38 +6,53 @@ import TPDB.DP.Unify import TPDB.DP.TCap -import qualified Data.Set as S +import qualified Data.IntSet as S +import qualified Data.IntMap.Strict as M --- | DANGER: this ignores the CE condition -restrict :: (Ord c, Ord v) => RS c (Term v c) -> RS c (Term v c) +-- | restrict one SCC to its usable rules. +-- DANGER: this ignores the CE condition +restrict :: (Eq c, Ord v, TermC v c) => RS c (Term v c) -> RS c (Term v c) restrict dp = dp { rules = filter strict (rules dp) - ++ S.toList ( usable dp) + ++ usable dp } -- | computes the least closed set of usable rules, cf. Def 4.5 -- http://cl-informatik.uibk.ac.at/users/griff/publications/Sternagel-Thiemann-RTA10.pdf -usable :: (Ord v, Ord c) - => TRS v c -> S.Set (Rule (Term v c)) -usable dp = fixpoint ( \ s -> S.union s $ required dp s) - (required dp $ S.filter strict - $ S.fromList $ rules dp) +usable :: (Eq c, Ord v, TermC v c) + => TRS v c -> [Rule (Term v c)] +usable dp = + let dpi = M.fromList $ zip [0..] $ rules dp + fp = fixpoint + ( \ s -> S.union s $ required dpi $ S.toList s) + (required dpi $ map fst $ filter (strict . snd) $ M.toList dpi) + in map (dpi M.!) $ S.toList fp fixpoint f x = let y = f x in if x == y then x else fixpoint f y -required :: (Ord v, Ord c) - => TRS v c -> S.Set ( Rule (Term v c) ) -> S.Set ( Rule (Term v c) ) -required dp rs = - S.fromList $ do { r <- S.toList rs ; needed dp $ rhs r } +-- | indices of rules that can be used +-- to rewrite rhs of rules with indices @is@ +required :: (Eq c, Ord v, TermC v c) + => M.IntMap ( Rule (Term v c) ) + -> [ Int ] + -> S.IntSet +required dpi is = S.fromList + $ concatMap (needed dpi) + $ map (rhs . (dpi M.!)) is -needed :: (Ord v, Ord c) - => TRS v c -> Term v c -> [ Rule (Term v c) ] -needed dp t = case t of - Node f args -> - filter ( \ u -> unifies ( vmap Left $ lhs u ) ( vmap Right $ tcap dp t ) ) - ( filter (not . strict) $ rules dp ) - ++ ( args >>= needed dp ) +-- | indices of rules that can be used +-- to rewrite the given term @t@ (including subterms) +needed :: (Eq c, Ord v, TermC v c) + => M.IntMap (Rule (Term v c)) + -> Term v c + -> [ Int ] +needed dpi t = case t of + Node f args -> (map fst + $ filter ( \ (j,u) -> unifies ( vmap Left $ lhs u ) ( vmap Right $ tcap (M.elems dpi) t ) ) + $ filter ( not . strict . snd) + $ M.toList dpi) + ++ ( args >>= needed dpi ) Var v -> [] diff --git a/src/TPDB/Data.hs b/src/TPDB/Data.hs --- a/src/TPDB/Data.hs +++ b/src/TPDB/Data.hs @@ -11,6 +11,7 @@ module TPDB.Data ( module TPDB.Data +, module TPDB.Data.Identifier , module TPDB.Data.Term , module TPDB.Data.Rule ) @@ -18,6 +19,7 @@ where +import TPDB.Data.Identifier import TPDB.Data.Term import TPDB.Data.Rule import TPDB.Data.Attributes @@ -31,27 +33,12 @@ import qualified Data.Text as T import qualified Data.Set as S -data Identifier = - Identifier { _identifier_hash :: !Int - , name :: !T.Text - , arity :: Int - } - deriving ( Eq, Ord, Typeable ) -instance Hashable Identifier where - hashWithSalt s i = hash (s, _identifier_hash i) - -instance Show Identifier where show = T.unpack . name - -mk :: Int -> T.Text -> Identifier -mk a n = Identifier { _identifier_hash = hash (a,n) - , arity = a, name = n } - class Ord (Var t) => Variables t where type Var t variables :: t -> S.Set (Var t) -instance Ord v => Variables (Term v c) where +instance (Ord v, TermC v c) => Variables (Term v c) where type Var (Term v c) = v variables = vars @@ -109,7 +96,7 @@ variables u = S.unions [ variables (lhs u), variables (rhs u) ] -instance Ord v => Variables (TRS v s) where +instance (Ord v, TermC v s) => Variables (TRS v s) where type Var (TRS v s) = v variables sys = S.unions $ map variables $ rules sys diff --git a/src/TPDB/Data/Attributes.hs b/src/TPDB/Data/Attributes.hs --- a/src/TPDB/Data/Attributes.hs +++ b/src/TPDB/Data/Attributes.hs @@ -39,7 +39,7 @@ compute_attributes - :: (Ord v, Ord c) + :: (Ord v, Ord c, TermC v c) => [Rule (Term v c)] -> Attributes compute_attributes us = let terms = do u <- us; [lhs u, rhs u] @@ -67,11 +67,11 @@ safe_maximum x [] = x safe_maximum x ys = maximum ys -varcount :: Ord v => Rule (Term v c) -> M.Map v (Int,Int) +varcount :: (Ord v, TermC v c) => Rule (Term v c) -> M.Map v (Int,Int) varcount u = M.mergeWithKey ( \ k l r -> Just (l,r)) ( M.map ( \k -> (k,0))) (M.map ( \k -> (0,k))) (varcount_term $ lhs u) (varcount_term $ rhs u) -varcount_term :: Ord v => Term v c -> M.Map v Int +varcount_term :: (Ord v, TermC v c) => Term v c -> M.Map v Int varcount_term t = M.fromListWith (+) $ do (p, Var v) <- positions t return (v, 1) diff --git a/src/TPDB/Data/Identifier.hs b/src/TPDB/Data/Identifier.hs new file mode 100644 --- /dev/null +++ b/src/TPDB/Data/Identifier.hs @@ -0,0 +1,21 @@ +module TPDB.Data.Identifier where + +import qualified Data.Text as T +import Data.Typeable +import Data.Hashable + +data Identifier = + Identifier { _identifier_hash :: !Int + , name :: !T.Text + , arity :: Int + } + deriving ( Eq, Ord, Typeable ) + +instance Hashable Identifier where + hashWithSalt _ = _identifier_hash + +instance Show Identifier where show = T.unpack . name + +mk :: Int -> T.Text -> Identifier +mk a n = Identifier { _identifier_hash = hash (a,n) + , arity = a, name = n } diff --git a/src/TPDB/Data/Rule.hs b/src/TPDB/Data/Rule.hs --- a/src/TPDB/Data/Rule.hs +++ b/src/TPDB/Data/Rule.hs @@ -1,13 +1,20 @@ module TPDB.Data.Rule where +import TPDB.Data.Identifier import Data.Typeable data Relation = Strict | Weak | Equal deriving ( Eq, Ord, Typeable, Show ) -data Rule a = Rule { lhs :: a, rhs :: a - , relation :: Relation - , top :: Bool - } +data Rule a = Rule + { lhs :: a, rhs :: a + , relation :: Relation + , top :: Bool + -- TPDC (XTC) represents SRS as TRS, + -- e.g., "ab -> ba" is "a(b(x)) -> b(a(x))", + -- and when we convert back (as we need for CPF), + -- need to use the original variable in the rule + , original_variable :: Maybe Identifier + } deriving ( Eq, Ord, Typeable ) strict :: Rule a -> Bool diff --git a/src/TPDB/Data/Term.hs b/src/TPDB/Data/Term.hs --- a/src/TPDB/Data/Term.hs +++ b/src/TPDB/Data/Term.hs @@ -1,28 +1,24 @@ -{-# language DeriveDataTypeable #-} +module TPDB.Data.Term (module T, module TPDB.Data.Term) where -module TPDB.Data.Term where +import TPDB.Data.Term.Plain as T +-- import TPDB.Data.Term.Cached as T import qualified Data.Set as S -import Data.Set (Set) -import Data.Typeable -data Term v s = Var v - | Node s [ Term v s ] - deriving ( Eq, Ord, Show, Typeable ) -vmap :: ( v -> u ) -> Term v s -> Term u s -vmap f ( Var v ) = Var ( f v ) -vmap f ( Node c args ) = Node c $ map ( vmap f ) args - -instance Functor ( Term v ) where - fmap f ( Var v ) = Var v - fmap f ( Node c args ) = Node (f c) ( map ( fmap f ) args ) +{-# INLINEABLE vmap #-} +vmap :: (TermC v s, TermC u s) => ( v -> u ) -> Term v s -> Term u s +vmap f = tfold (Var . f) Node +-- instance Functor ( Term v ) where +-- cannot instantiate Functor since we need TermC +{-# INLINEABLE tmap #-} +tmap f = tfold Var ( \ c xs -> Node (f c) xs) type Position = [ Int ] -positions :: Term v c +positions :: TermC v c => Term v c -> [ ( Position, Term v c ) ] positions t = ( [], t ) : case t of Node c args -> do ( k, arg ) <- zip [ 0 .. ] args @@ -30,78 +26,72 @@ return ( k : p , s ) _ -> [] --- FIXME: inefficient implementation (walks the tree), --- should store the result in each node instead, --- but this would break pattern matching. -size :: Term v c -> Int -size t = length $ positions t -depth :: Term v c -> Int -depth t = case t of - Var {} -> 0 - Node f args -> case args of - [] -> 0 - _ -> 1 + maximum (map depth args) - -- | all positions -pos :: Term v c +pos :: TermC v c => Term v c -> [ Position ] pos t = do ( p, s ) <- positions t return p -- | non-variable positions -sympos :: Term v c +sympos :: TermC v c => Term v c -> [ Position ] sympos t = do ( p, Node {} ) <- positions t return p -- | variable positions -varpos :: Term v c +varpos :: TermC v c => Term v c -> [ Position ] -varpos t = do +varpos t = -- if null (vars t) then [] else + do ( p, Var {} ) <- positions t return p -- | leaf positions (= nullary symbols) -leafpos :: Term v c +leafpos :: TermC v c => Term v c -> [ Position ] leafpos t = do ( p, Node c [] ) <- positions t return p -{-# inline subterms #-} - -subterms :: Term v c +-- | in preorder +{-# INLINE subterms #-} +subterms :: TermC v c => Term v c -> [ Term v c ] subterms t = t : case t of - Node c args -> do arg <- args - subterms arg + Node c args -> args >>= subterms _ -> [] -- Note: following implementation relies on @subterms@ -- returning the preorder list (where the full term goes first) strict_subterms t = tail $ subterms t -isSubtermOf :: (Eq v, Eq c ) +isSubtermOf :: (TermC v c, Eq v, Eq c ) => Term v c -> Term v c -> Bool -isSubtermOf s t = elem s $ subterms t +isSubtermOf s t = + -- size s <= size t && + (elem s $ subterms t) -isStrictSubtermOf :: (Eq v, Eq c ) +isStrictSubtermOf :: (TermC v c, Eq v, Eq c ) => Term v c -> Term v c -> Bool -isStrictSubtermOf s t = elem s $ strict_subterms t +isStrictSubtermOf s t = + -- size s < size t && + (elem s $ strict_subterms t) -- | compute new symbol at position, giving the position -pmap:: ( Position -> c -> d ) +pmap :: (TermC v c, TermC v d) + =>( Position -> c -> d ) -> Term v c -> Term v d pmap f = rpmap ( \ p c -> f ( reverse p) c ) -- | compute new symbol from *reverse* position and previous symbol -- this is more efficient (no reverse needed) -rpmap :: ( Position -> c -> d ) +rpmap :: (TermC v c, TermC v d) + => ( Position -> c -> d ) -> Term v c -> Term v d rpmap f t = helper [] t where @@ -112,13 +102,15 @@ -peek :: Term v c +peek :: TermC v c + => Term v c -> Position -> Term v c peek t [] = t peek ( Node c args ) ( k : ks ) = peek ( args !! k ) ks -peek_symbol :: Term v c +peek_symbol :: TermC v c + => Term v c -> Position -> c peek_symbol t p = @@ -127,7 +119,8 @@ _ -> error "Autolib.TES.Position.peek_symbol called for non-symbol" -- | warning: don't check arity -poke_symbol :: Term v c +poke_symbol :: TermC v c + => Term v c -> ( Position , c ) -> Term v c poke_symbol t ( p, c ) = @@ -135,7 +128,8 @@ Node _ args -> poke t ( p, Node c args ) _ -> error "Autolib.TES.Position.poke_symbol called for non-symbol" -poke :: Term v c +poke :: TermC v c + => Term v c -> ( Position , Term v c ) -> Term v c poke t ( [], s ) = s @@ -143,38 +137,30 @@ let ( pre , this : post ) = splitAt k args in Node c ( pre ++ poke this ( ks, s ) : post ) -pokes :: Term v c +pokes :: TermC v c + => Term v c -> [ ( Position, Term v c ) ] -> Term v c pokes = foldl poke --- | in preorder -symsl :: Term v c -> [ c ] -symsl t = do - Node c _ <- subterms t - return c - -syms :: Ord c => Term v c -> Set c -syms = S.fromList . symsl - +-- | list of function symbols (in pre-order, with duplicates) +symsl :: TermC v c => Term v c -> [ c ] +symsl t = do Node c _ <- subterms t; return c -lsyms :: Ord c => Term v c -> [ c ] +-- | unique +lsyms :: (Ord c, TermC v c) => Term v c -> [ c ] lsyms = S.toList . syms -vars :: Ord v => Term v c -> Set v -vars t = S.fromList $ do - Var v <- subterms t - return v - -isvar :: Term v c -> Bool +isvar :: TermC v c => Term v c -> Bool isvar ( Var _ ) = True ; isvar _ = False -- | list of variables (each occurs once, unspecified ordering) -lvars :: Ord v => Term v c -> [ v ] +lvars :: (Ord v, TermC v c) => Term v c -> [ v ] lvars = S.toList . vars -- | list of variables (in pre-order, with duplicates) -voccs :: Term v c -> [ v ] -voccs t = do ( p, Var v ) <- positions t ; return v +{-# INLINE voccs #-} +voccs :: TermC v c => Term v c -> [ v ] +voccs = tfold (\ v -> [v]) (\ _ -> concat) diff --git a/src/TPDB/Data/Term/Cached.hs b/src/TPDB/Data/Term/Cached.hs new file mode 100644 --- /dev/null +++ b/src/TPDB/Data/Term/Cached.hs @@ -0,0 +1,111 @@ +{-# language DeriveDataTypeable #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE ConstraintKinds #-} +{-# LANGUAGE DeriveGeneric #-} + +module TPDB.Data.Term.Cached + ( TermC, Term, pattern Var, pattern Node, tfold + , size, depth, vars, syms + ) +where + +import qualified Data.Set as S +import Data.Set (Set) +import Data.Typeable +import Data.Hashable +import GHC.Generics + +data Term v s = Var_Imp + { _hash :: !Int + , name :: v + -- , size :: !Int + -- , depth :: !Int + -- , vars :: S.Set v + -- , syms :: S.Set s + } + | Node_Imp + { _hash :: !Int + , fun :: s + , args :: [Term v s] + -- , size :: !Int + -- , depth :: !Int + -- , vars :: S.Set v + -- , syms :: S.Set s + } + deriving ( Eq, Ord, Typeable, Generic ) + +vars :: TermC v c => Term v c -> S.Set v +vars = tfold S.singleton (\ _ -> S.unions) + +syms :: TermC v c => Term v c -> S.Set c +syms = tfold (const S.empty) (\ f xs -> S.unions $ S.singleton f : xs) + +size :: TermC v c => Term v c -> Int +size = tfold (const 0) (\ _ -> succ . sum ) + +depth :: TermC v c => Term v c -> Int +depth = tfold (const 0) (\ _ xs -> if null xs then 0 else succ $ maximum xs) + +{- +instance TermC v s => Eq (Term v s) where + s == t = hash s == hash t && case (s,t) of + (Var x, Var y) -> x == y + (Node f xs, Node g ys) -> (f,xs) == (g,ys) + _ -> False +-} + +{- +instance TermC v s => Ord (Term v s) where + compare s t = + case compare (hash s) (hash t) of + EQ -> case (s,t) of + (Var x, Var y) -> compare x y + (Node f xs, Node g ys) -> compare (f,xs) (g,ys) + (Var _, Node _ _) -> LT + (Node _ _, Var _) -> GT + c -> c +-} + +instance TermC v s => Hashable (Term v s) + where hashWithSalt _ = _hash + + +pattern Var :: TermC v s => () => + v -> Term v s +pattern Var v <- Var_Imp { name = v } where + Var v = Var_Imp { name = v + ,_hash = hash v + -- , size = 1, depth = 0 + -- , vars = S.singleton v + -- , syms = mempty + } + +pattern Node :: TermC v s => () => + s -> [Term v s] -> Term v s +pattern Node f xs <- Node_Imp { fun = f, args = xs } where + Node f xs = Node_Imp { fun = f, args = xs + , _hash = hash (f, xs) + -- , size = 1 + sum (map size xs) + -- , depth = if null xs then 0 else succ $ maximum $ map depth xs + -- , vars = S.unions $ map vars xs + -- , syms = S.unions $ map syms xs + } + +type TermC v s = (Hashable v, Hashable s, Ord v, Ord s) + +{-# INLINEABLE vmap #-} +vmap :: (TermC v s, TermC u s) => ( v -> u ) -> Term v s -> Term u s +vmap f = tfold (Var . f) Node + +-- instance Functor ( Term v ) where +-- cannot instantiate Functor since we need TermC +{-# INLINEABLE tmap #-} +tmap f = tfold Var ( \ c xs -> Node (f c) xs) + +{-# INLINE tfold #-} +tfold :: TermC v c => (v -> r) -> (c -> [r] -> r) -> Term v c -> r +tfold var node t = + let go (Var v) = var v + go (Node f xs) = node f (map go xs) + in go t + diff --git a/src/TPDB/Data/Term/Plain.hs b/src/TPDB/Data/Term/Plain.hs new file mode 100644 --- /dev/null +++ b/src/TPDB/Data/Term/Plain.hs @@ -0,0 +1,52 @@ +{-# language DeriveDataTypeable #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE ConstraintKinds #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE DeriveFunctor #-} + +module TPDB.Data.Term.Plain +( TermC, Term (..), tfold + , size, depth, vars, syms + ) +where + +import qualified Data.Set as S +import Data.Set (Set) +import Data.Typeable +import Data.Hashable +import GHC.Generics +import Data.Kind + +-- | we do derive Ord but it should probably not be used much +data Term v s = Var v | Node s [Term v s] + deriving ( Eq + , Ord + , Typeable, Generic, Functor ) + +{-# INLINE tfold #-} +tfold :: TermC v c => (v -> r) -> (c -> [r] -> r) -> Term v c -> r +tfold var node = + let go (Var v) = var v + go (Node f xs) = node f (map go xs) + in go + +vars :: Ord v => Term v c -> S.Set v +vars = tfold S.singleton (\ _ -> S.unions) + +syms :: Ord c => Term v c -> S.Set c +syms = tfold (const S.empty) (\ f xs -> S.unions $ S.singleton f : xs) + +size :: TermC v c => Term v c -> Int +size = tfold (const 0) (\ _ -> succ . sum ) + +depth :: TermC v c => Term v c -> Int +depth = tfold (const 0) (\ _ xs -> if null xs then 0 else succ $ maximum xs) + +instance (Hashable v, Hashable s) => Hashable (Term v s) + +type TermC v s = () :: Constraint + -- (Hashable v, Hashable s, Ord v, Ord s) + + + diff --git a/src/TPDB/Data/Xml.hs b/src/TPDB/Data/Xml.hs --- a/src/TPDB/Data/Xml.hs +++ b/src/TPDB/Data/Xml.hs @@ -25,7 +25,7 @@ [xml|#{fromString $ escape $ show i}|] -instance ( Show v, XmlContent v, XmlContent c ) +instance ( TermC v c, Show v, XmlContent v, XmlContent c ) => XmlContent ( Term v c ) where toContents ( Var v ) = [xml|#{fromString $ show v}|] {- @@ -69,7 +69,7 @@ -instance ( XmlContent ( Term v c ) ) +instance ( TermC v c, XmlContent ( Term v c ) ) => XmlContent ( Rule ( Term v c ) ) where toContents u = [xml| diff --git a/src/TPDB/Mirror.hs b/src/TPDB/Mirror.hs --- a/src/TPDB/Mirror.hs +++ b/src/TPDB/Mirror.hs @@ -6,8 +6,9 @@ import Control.Monad ( forM, guard ) -- | if input is SRS, reverse lhs and rhs of each rule -mirror :: TRS Identifier s - -> Maybe ( TRS Identifier s ) +mirror :: (Eq v, TermC v s) + => TRS v s + -> Maybe ( TRS v s ) mirror trs = do us <- forM (rules trs) $ \ u -> do ( left_spine, left_base ) <- spine $ lhs u diff --git a/src/TPDB/Plain/Read.hs b/src/TPDB/Plain/Read.hs --- a/src/TPDB/Plain/Read.hs +++ b/src/TPDB/Plain/Read.hs @@ -1,7 +1,7 @@ -- | textual input, -- cf. -{-# language PatternSignatures, TypeSynonymInstances, FlexibleInstances #-} +{-# language PatternSignatures, TypeSynonymInstances, FlexibleInstances, FlexibleContexts #-} module TPDB.Plain.Read where @@ -67,7 +67,7 @@ -- NOTE: this is dangerous since we read the variables as constants, -- and this needs to be patched up later. -- NOTE: this is more dangerous as we do not set the arity of identifiers -instance ( Reader v ) => Reader ( Term v Identifier ) where +instance ( TermC v Identifier, Reader v ) => Reader ( Term v Identifier ) where reader = do f <- reader xs <- ( parens lexer $ commaSep lexer reader ) <|> return [] @@ -82,7 +82,9 @@ -- as it would deviate from published TPDB syntax -- <|> do reservedOp lexer "=" ; return Equal r <- reader - return $ Rule { lhs = l, relation = rel, top = False, rhs = r } + return $ Rule { lhs = l, relation = rel, top = False, rhs = r + , original_variable = Nothing + } data Declaration u = Var_Declaration [ Identifier ] diff --git a/src/TPDB/Plain/Write.hs b/src/TPDB/Plain/Write.hs --- a/src/TPDB/Plain/Write.hs +++ b/src/TPDB/Plain/Write.hs @@ -18,7 +18,7 @@ instance Pretty Identifier where pretty i = pretty $ name i -instance ( Pretty v, Pretty s ) => Pretty ( Term v s ) where +instance ( TermC v s, Pretty v, Pretty s ) => Pretty ( Term v s ) where pretty t = case t of Var v -> pretty v Node f xs -> case xs of @@ -41,34 +41,32 @@ instance Pretty s => PrettyTerm [s] where prettyTerm xs = hsep $ map pretty xs -instance ( Pretty v, Pretty s ) => PrettyTerm ( Term v s ) where +instance ( TermC v s, Pretty v, Pretty s ) => PrettyTerm ( Term v s ) where prettyTerm = pretty instance ( Pretty s, PrettyTerm r, Variables (RS s r) , Pretty (Var (RS s r))) => Pretty ( RS s r ) where - pretty sys = vcat - [ let vs = S.toList $ variables sys - in if null vs - then empty - else parens $ "VAR" <+> vcat (map pretty vs) - , parens $ "RULES" <+> - vcat ( ( if separate sys then punctuate comma else id ) + pretty sys = + let vs = S.toList $ variables sys + vars = parens $ "VAR" <+> vcat (map pretty vs) + ruls = parens $ "RULES" <+> + vcat ( ( if separate sys then punctuate comma else id ) $ map pretty $ rules sys - ) + ) + in if null vs then ruls else vcat [vars, ruls] -- FIXME: output strategy, theory - ] -instance ( Pretty s, Pretty r, Variables (Term s r) ) => Pretty ( Problem s r ) where +instance ( TermC s r, Pretty s, Pretty r, Variables (Term s r) ) => Pretty ( Problem s r ) where pretty p = let rms = case full_signature p of HigherOrderSignature -> [] - Signature fs -> do - f <- fs - case fs_replacementmap f of - Nothing -> [] - Just (Replacementmap ps) -> - return $ parens $ sep $ pretty (fs_name f) : map pretty ps + Signature fs -> do + f <- fs + case fs_replacementmap f of + Nothing -> [] + Just (Replacementmap ps) -> + return $ parens $ sep $ pretty (fs_name f) : map pretty ps in vcat [ pretty $ trs p , if null rms then empty diff --git a/src/TPDB/XTC/Write.hs b/src/TPDB/XTC/Write.hs --- a/src/TPDB/XTC/Write.hs +++ b/src/TPDB/XTC/Write.hs @@ -24,7 +24,7 @@ root = X.Element "problem" (M.fromList [("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance") ,("type","termination") - ,("xsi:noNamespaceSchemaLocation","http://dev.aspsimon.org/xtc.xsd") + ,("xsi:noNamespaceSchemaLocation","xtc.xsd") ]) [xml| ^{trs $ D.trs p} @@ -38,10 +38,12 @@ trs :: D.TRS D.Identifier D.Identifier -> [X.Node] trs rs = [xml| - $forall u <- D.rules rs - - ^{term $ D.lhs u} - ^{term $ D.rhs u} + $forall u <- D.strict_rules rs + ^{rule u} + $if not (null (D.weak_rules rs)) + + $forall u <- D.weak_rules rs + ^{rule u} $forall f <- D.signature rs @@ -49,6 +51,12 @@ #{T.pack $ show $ D.arity f} |] +rule (l,r) = [xml| + + ^{term l} + ^{term r} +|] + term :: D.Term D.Identifier D.Identifier -> [X.Node] term t = case t of D.Var v -> [xml| diff --git a/test/dp-performance.hs b/test/dp-performance.hs new file mode 100644 --- /dev/null +++ b/test/dp-performance.hs @@ -0,0 +1,28 @@ +import TPDB.Data (rules) +import TPDB.Plain.Write +import TPDB.Plain.Read +import TPDB.Pretty + +import qualified TPDB.DP.Transform as DT +import qualified TPDB.DP.Graph as DG +import qualified TPDB.DP.Usable as DU + +import Data.Either +import Data.Text.Lazy.IO as T +import Control.Monad ( forM, void ) +import System.IO (stdout) +import Text.Printf + +main = void $ do + s <- T.readFile "test/labelled.trs" + case trs s of + Left err -> error err + Right r -> do + printf "R has %d rules\n" (length $ rules r) + let d = DT.dp r + printf "DP(R) has %d rules\n" (length $ rules d) + let c = rights $ DG.components d + printf "EDG(R) has %d cyclic components with sizes %s\n" + (length c) (show $ map (length . rules) c) + let u = map DU.restrict c + printf "usable sizes %s\n" (show $ map (length . rules) u) diff --git a/test/labelled.trs b/test/labelled.trs new file mode 100644 --- /dev/null +++ b/test/labelled.trs @@ -0,0 +1,1883 @@ +(VAR x y z) +(RULES + A_0_4 (A_3_4 (A_4_4 (S, x), y), z) -> A_3_3 (A_4_4 (x, z), A_4_4 (y, z)) + A_1_4 (A_3_3 (A_4_4 (S, x), y), z) -> A_3_0 (A_4_4 (x, z), A_3_4 (y, z)) + A_2_4 (A_3_0 (A_4_4 (S, x), y), z) -> A_3_1 (A_4_4 (x, z), A_0_4 (y, z)) + A_2_4 (A_3_1 (A_4_4 (S, x), y), z) -> A_3_2 (A_4_4 (x, z), A_1_4 (y, z)) + A_2_4 (A_3_2 (A_4_4 (S, x), y), z) -> A_3_2 (A_4_4 (x, z), A_2_4 (y, z)) + A_9_4 (A_3_5 (A_4_4 (S, x), y), z) -> A_3_19 (A_4_4 (x, z), A_5_4 (y, z)) + A_9_4 (A_3_9 (A_4_4 (S, x), y), z) -> A_3_19 (A_4_4 (x, z), A_9_4 (y, z)) + A_8_4 (A_3_6 (A_4_4 (S, x), y), z) -> A_3_20 (A_4_4 (x, z), A_6_4 (y, z)) + A_8_4 (A_3_8 (A_4_4 (S, x), y), z) -> A_3_20 (A_4_4 (x, z), A_8_4 (y, z)) + A_10_4 (A_3_7 (A_4_4 (S, x), y), z) -> A_3_21 (A_4_4 (x, z), A_7_4 (y, z)) + A_10_4 (A_3_10 (A_4_4 (S, x), y), z) -> A_3_21 (A_4_4 (x, z), A_10_4 (y, z)) + A_12_4 (A_3_11 (A_4_4 (S, x), y), z) -> A_3_25 (A_4_4 (x, z), A_11_4 (y, z)) + A_12_4 (A_3_12 (A_4_4 (S, x), y), z) -> A_3_25 (A_4_4 (x, z), A_12_4 (y, z)) + A_0_3 (A_3_4 (A_4_4 (S, x), y), z) -> A_5_5 (A_4_3 (x, z), A_4_3 (y, z)) + A_19_4 (A_3_19 (A_4_4 (S, x), y), z) -> A_3_27 (A_4_4 (x, z), A_19_4 (y, z)) + A_19_4 (A_5_4 (A_4_3 (S, x), y), z) -> A_0_3 (A_3_4 (x, z), A_4_4 (y, z)) + A_14_4 (A_3_13 (A_4_4 (S, x), y), z) -> A_3_30 (A_4_4 (x, z), A_13_4 (y, z)) + A_14_4 (A_3_14 (A_4_4 (S, x), y), z) -> A_3_30 (A_4_4 (x, z), A_14_4 (y, z)) + A_8_3 (A_3_6 (A_4_4 (S, x), y), z) -> A_5_29 (A_4_3 (x, z), A_6_3 (y, z)) + A_8_3 (A_3_8 (A_4_4 (S, x), y), z) -> A_5_31 (A_4_3 (x, z), A_8_3 (y, z)) + A_10_3 (A_3_7 (A_4_4 (S, x), y), z) -> A_5_30 (A_4_3 (x, z), A_7_3 (y, z)) + A_10_3 (A_3_10 (A_4_4 (S, x), y), z) -> A_5_31 (A_4_3 (x, z), A_10_3 (y, z)) + A_14_3 (A_3_13 (A_4_4 (S, x), y), z) -> A_5_31 (A_4_3 (x, z), A_13_3 (y, z)) + A_14_3 (A_3_14 (A_4_4 (S, x), y), z) -> A_5_31 (A_4_3 (x, z), A_14_3 (y, z)) + A_16_3 (A_3_15 (A_4_4 (S, x), y), z) -> A_5_31 (A_4_3 (x, z), A_15_3 (y, z)) + A_16_3 (A_3_16 (A_4_4 (S, x), y), z) -> A_5_31 (A_4_3 (x, z), A_16_3 (y, z)) + A_16_4 (A_3_15 (A_4_4 (S, x), y), z) -> A_3_31 (A_4_4 (x, z), A_15_4 (y, z)) + A_16_4 (A_3_16 (A_4_4 (S, x), y), z) -> A_3_31 (A_4_4 (x, z), A_16_4 (y, z)) + A_1_3 (A_3_3 (A_4_4 (S, x), y), z) -> A_5_1 (A_4_3 (x, z), A_3_3 (y, z)) + A_20_4 (A_3_20 (A_4_4 (S, x), y), z) -> A_3_32 (A_4_4 (x, z), A_20_4 (y, z)) + A_20_4 (A_6_4 (A_4_0 (S, x), y), z) -> A_1_3 (A_0_4 (x, z), A_4_4 (y, z)) + A_2_3 (A_3_0 (A_4_4 (S, x), y), z) -> A_5_27 (A_4_3 (x, z), A_0_3 (y, z)) + A_2_3 (A_3_1 (A_4_4 (S, x), y), z) -> A_5_32 (A_4_3 (x, z), A_1_3 (y, z)) + A_2_3 (A_3_2 (A_4_4 (S, x), y), z) -> A_5_33 (A_4_3 (x, z), A_2_3 (y, z)) + A_9_3 (A_3_5 (A_4_4 (S, x), y), z) -> A_5_17 (A_4_3 (x, z), A_5_3 (y, z)) + A_9_3 (A_3_9 (A_4_4 (S, x), y), z) -> A_5_33 (A_4_3 (x, z), A_9_3 (y, z)) + A_12_3 (A_3_11 (A_4_4 (S, x), y), z) -> A_5_22 (A_4_3 (x, z), A_11_3 (y, z)) + A_12_3 (A_3_12 (A_4_4 (S, x), y), z) -> A_5_33 (A_4_3 (x, z), A_12_3 (y, z)) + A_21_4 (A_3_21 (A_4_4 (S, x), y), z) -> A_3_33 (A_4_4 (x, z), A_21_4 (y, z)) + A_21_4 (A_7_4 (A_4_1 (S, x), y), z) -> A_2_3 (A_1_4 (x, z), A_4_4 (y, z)) + A_21_4 (A_7_4 (A_4_2 (S, x), y), z) -> A_2_3 (A_2_4 (x, z), A_4_4 (y, z)) + A_1_0 (A_3_3 (A_4_4 (S, x), y), z) -> A_6_2 (A_4_0 (x, z), A_3_0 (y, z)) + A_29_4 (A_3_29 (A_4_4 (S, x), y), z) -> A_3_34 (A_4_4 (x, z), A_29_4 (y, z)) + A_29_4 (A_6_3 (A_4_0 (S, x), y), z) -> A_1_0 (A_0_4 (x, z), A_3_4 (y, z)) + A_1_1 (A_3_3 (A_4_4 (S, x), y), z) -> A_7_2 (A_4_1 (x, z), A_3_1 (y, z)) + A_1_2 (A_3_3 (A_4_4 (S, x), y), z) -> A_7_2 (A_4_2 (x, z), A_3_2 (y, z)) + A_17_3 (A_5_3 (A_4_3 (S, x), y), z) -> A_1_1 (A_3_3 (x, z), A_3_3 (y, z)) + A_34_4 (A_3_34 (A_4_4 (S, x), y), z) -> A_3_35 (A_4_4 (x, z), A_34_4 (y, z)) + A_34_4 (A_6_0 (A_4_0 (S, x), y), z) -> A_1_1 (A_0_4 (x, z), A_0_4 (y, z)) + A_34_4 (A_6_1 (A_4_0 (S, x), y), z) -> A_1_2 (A_0_4 (x, z), A_1_4 (y, z)) + A_34_4 (A_6_2 (A_4_0 (S, x), y), z) -> A_1_2 (A_0_4 (x, z), A_2_4 (y, z)) + A_0_0 (A_3_4 (A_4_4 (S, x), y), z) -> A_6_6 (A_4_0 (x, z), A_4_0 (y, z)) + A_0_1 (A_3_4 (A_4_4 (S, x), y), z) -> A_7_7 (A_4_1 (x, z), A_4_1 (y, z)) + A_0_2 (A_3_4 (A_4_4 (S, x), y), z) -> A_7_7 (A_4_2 (x, z), A_4_2 (y, z)) + A_0_5 (A_3_4 (A_4_4 (S, x), y), z) -> A_11_11 (A_4_5 (x, z), A_4_5 (y, z)) + A_1_5 (A_3_3 (A_4_4 (S, x), y), z) -> A_11_9 (A_4_5 (x, z), A_3_5 (y, z)) + A_1_9 (A_3_3 (A_4_4 (S, x), y), z) -> A_13_9 (A_4_9 (x, z), A_3_9 (y, z)) + A_1_11 (A_3_3 (A_4_4 (S, x), y), z) -> A_15_12 (A_4_11 (x, z), A_3_11 (y, z)) + A_1_12 (A_3_3 (A_4_4 (S, x), y), z) -> A_15_12 (A_4_12 (x, z), A_3_12 (y, z)) + A_2_0 (A_3_0 (A_4_4 (S, x), y), z) -> A_6_36 (A_4_0 (x, z), A_0_0 (y, z)) + A_2_0 (A_3_1 (A_4_4 (S, x), y), z) -> A_6_34 (A_4_0 (x, z), A_1_0 (y, z)) + A_2_0 (A_3_2 (A_4_4 (S, x), y), z) -> A_6_36 (A_4_0 (x, z), A_2_0 (y, z)) + A_2_1 (A_3_0 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_1 (x, z), A_0_1 (y, z)) + A_2_1 (A_3_1 (A_4_4 (S, x), y), z) -> A_7_35 (A_4_1 (x, z), A_1_1 (y, z)) + A_2_1 (A_3_2 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_1 (x, z), A_2_1 (y, z)) + A_2_2 (A_3_0 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_2 (x, z), A_0_2 (y, z)) + A_2_2 (A_3_1 (A_4_4 (S, x), y), z) -> A_7_35 (A_4_2 (x, z), A_1_2 (y, z)) + A_2_2 (A_3_2 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_2 (x, z), A_2_2 (y, z)) + A_8_0 (A_3_6 (A_4_4 (S, x), y), z) -> A_6_34 (A_4_0 (x, z), A_6_0 (y, z)) + A_8_0 (A_3_8 (A_4_4 (S, x), y), z) -> A_6_36 (A_4_0 (x, z), A_8_0 (y, z)) + A_8_1 (A_3_6 (A_4_4 (S, x), y), z) -> A_7_34 (A_4_1 (x, z), A_6_1 (y, z)) + A_8_1 (A_3_8 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_1 (x, z), A_8_1 (y, z)) + A_8_2 (A_3_6 (A_4_4 (S, x), y), z) -> A_7_34 (A_4_2 (x, z), A_6_2 (y, z)) + A_8_2 (A_3_8 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_2 (x, z), A_8_2 (y, z)) + A_9_0 (A_3_5 (A_4_4 (S, x), y), z) -> A_6_32 (A_4_0 (x, z), A_5_0 (y, z)) + A_9_0 (A_3_9 (A_4_4 (S, x), y), z) -> A_6_36 (A_4_0 (x, z), A_9_0 (y, z)) + A_9_1 (A_3_5 (A_4_4 (S, x), y), z) -> A_7_32 (A_4_1 (x, z), A_5_1 (y, z)) + A_9_1 (A_3_9 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_1 (x, z), A_9_1 (y, z)) + A_9_2 (A_3_5 (A_4_4 (S, x), y), z) -> A_7_32 (A_4_2 (x, z), A_5_2 (y, z)) + A_9_2 (A_3_9 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_2 (x, z), A_9_2 (y, z)) + A_10_0 (A_3_7 (A_4_4 (S, x), y), z) -> A_6_35 (A_4_0 (x, z), A_7_0 (y, z)) + A_10_0 (A_3_10 (A_4_4 (S, x), y), z) -> A_6_36 (A_4_0 (x, z), A_10_0 (y, z)) + A_10_1 (A_3_7 (A_4_4 (S, x), y), z) -> A_7_35 (A_4_1 (x, z), A_7_1 (y, z)) + A_10_1 (A_3_10 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_1 (x, z), A_10_1 (y, z)) + A_10_2 (A_3_7 (A_4_4 (S, x), y), z) -> A_7_35 (A_4_2 (x, z), A_7_2 (y, z)) + A_10_2 (A_3_10 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_2 (x, z), A_10_2 (y, z)) + A_12_0 (A_3_11 (A_4_4 (S, x), y), z) -> A_6_36 (A_4_0 (x, z), A_11_0 (y, z)) + A_12_0 (A_3_12 (A_4_4 (S, x), y), z) -> A_6_36 (A_4_0 (x, z), A_12_0 (y, z)) + A_12_1 (A_3_11 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_1 (x, z), A_11_1 (y, z)) + A_12_1 (A_3_12 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_1 (x, z), A_12_1 (y, z)) + A_12_2 (A_3_11 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_2 (x, z), A_11_2 (y, z)) + A_12_2 (A_3_12 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_2 (x, z), A_12_2 (y, z)) + A_14_0 (A_3_13 (A_4_4 (S, x), y), z) -> A_6_36 (A_4_0 (x, z), A_13_0 (y, z)) + A_14_0 (A_3_14 (A_4_4 (S, x), y), z) -> A_6_36 (A_4_0 (x, z), A_14_0 (y, z)) + A_14_1 (A_3_13 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_1 (x, z), A_13_1 (y, z)) + A_14_1 (A_3_14 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_1 (x, z), A_14_1 (y, z)) + A_14_2 (A_3_13 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_2 (x, z), A_13_2 (y, z)) + A_14_2 (A_3_14 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_2 (x, z), A_14_2 (y, z)) + A_16_0 (A_3_15 (A_4_4 (S, x), y), z) -> A_6_36 (A_4_0 (x, z), A_15_0 (y, z)) + A_16_0 (A_3_16 (A_4_4 (S, x), y), z) -> A_6_36 (A_4_0 (x, z), A_16_0 (y, z)) + A_16_1 (A_3_15 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_1 (x, z), A_15_1 (y, z)) + A_16_1 (A_3_16 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_1 (x, z), A_16_1 (y, z)) + A_16_2 (A_3_15 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_2 (x, z), A_15_2 (y, z)) + A_16_2 (A_3_16 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_2 (x, z), A_16_2 (y, z)) + A_17_0 (A_5_3 (A_4_3 (S, x), y), z) -> A_2_2 (A_3_0 (x, z), A_3_0 (y, z)) + A_17_1 (A_5_3 (A_4_3 (S, x), y), z) -> A_2_2 (A_3_1 (x, z), A_3_1 (y, z)) + A_17_2 (A_5_3 (A_4_3 (S, x), y), z) -> A_2_2 (A_3_2 (x, z), A_3_2 (y, z)) + A_17_4 (A_5_3 (A_4_3 (S, x), y), z) -> A_0_0 (A_3_4 (x, z), A_3_4 (y, z)) + A_18_4 (A_3_18 (A_4_4 (S, x), y), z) -> A_3_36 (A_4_4 (x, z), A_18_4 (y, z)) + A_19_3 (A_3_19 (A_4_4 (S, x), y), z) -> A_5_36 (A_4_3 (x, z), A_19_3 (y, z)) + A_19_3 (A_5_4 (A_4_3 (S, x), y), z) -> A_1_5 (A_3_3 (x, z), A_4_3 (y, z)) + A_22_3 (A_3_22 (A_4_4 (S, x), y), z) -> A_5_36 (A_4_3 (x, z), A_22_3 (y, z)) + A_22_3 (A_11_3 (A_4_5 (S, x), y), z) -> A_17_1 (A_5_3 (x, z), A_3_3 (y, z)) + A_24_0 (A_3_17 (A_4_4 (S, x), y), z) -> A_6_36 (A_4_0 (x, z), A_17_0 (y, z)) + A_24_0 (A_3_24 (A_4_4 (S, x), y), z) -> A_6_36 (A_4_0 (x, z), A_24_0 (y, z)) + A_24_1 (A_3_17 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_1 (x, z), A_17_1 (y, z)) + A_24_1 (A_3_24 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_1 (x, z), A_24_1 (y, z)) + A_24_2 (A_3_17 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_2 (x, z), A_17_2 (y, z)) + A_24_2 (A_3_24 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_2 (x, z), A_24_2 (y, z)) + A_24_3 (A_3_17 (A_4_4 (S, x), y), z) -> A_5_35 (A_4_3 (x, z), A_17_3 (y, z)) + A_24_3 (A_3_24 (A_4_4 (S, x), y), z) -> A_5_36 (A_4_3 (x, z), A_24_3 (y, z)) + A_24_4 (A_3_17 (A_4_4 (S, x), y), z) -> A_3_36 (A_4_4 (x, z), A_17_4 (y, z)) + A_24_4 (A_3_24 (A_4_4 (S, x), y), z) -> A_3_36 (A_4_4 (x, z), A_24_4 (y, z)) + A_25_4 (A_3_25 (A_4_4 (S, x), y), z) -> A_3_36 (A_4_4 (x, z), A_25_4 (y, z)) + A_25_4 (A_11_4 (A_4_5 (S, x), y), z) -> A_19_3 (A_5_4 (x, z), A_4_4 (y, z)) + A_26_0 (A_3_23 (A_4_4 (S, x), y), z) -> A_6_36 (A_4_0 (x, z), A_23_0 (y, z)) + A_26_0 (A_3_26 (A_4_4 (S, x), y), z) -> A_6_36 (A_4_0 (x, z), A_26_0 (y, z)) + A_26_1 (A_3_23 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_1 (x, z), A_23_1 (y, z)) + A_26_1 (A_3_26 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_1 (x, z), A_26_1 (y, z)) + A_26_2 (A_3_23 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_2 (x, z), A_23_2 (y, z)) + A_26_2 (A_3_26 (A_4_4 (S, x), y), z) -> A_7_36 (A_4_2 (x, z), A_26_2 (y, z)) + A_26_3 (A_3_23 (A_4_4 (S, x), y), z) -> A_5_36 (A_4_3 (x, z), A_23_3 (y, z)) + A_26_3 (A_3_26 (A_4_4 (S, x), y), z) -> A_5_36 (A_4_3 (x, z), A_26_3 (y, z)) + A_26_4 (A_3_23 (A_4_4 (S, x), y), z) -> A_3_36 (A_4_4 (x, z), A_23_4 (y, z)) + A_26_4 (A_3_26 (A_4_4 (S, x), y), z) -> A_3_36 (A_4_4 (x, z), A_26_4 (y, z)) + A_30_4 (A_3_30 (A_4_4 (S, x), y), z) -> A_3_36 (A_4_4 (x, z), A_30_4 (y, z)) + A_30_4 (A_7_3 (A_4_1 (S, x), y), z) -> A_2_0 (A_1_4 (x, z), A_3_4 (y, z)) + A_30_4 (A_7_3 (A_4_2 (S, x), y), z) -> A_2_0 (A_2_4 (x, z), A_3_4 (y, z)) + A_30_4 (A_13_4 (A_4_9 (S, x), y), z) -> A_19_3 (A_9_4 (x, z), A_4_4 (y, z)) + A_32_4 (A_3_32 (A_4_4 (S, x), y), z) -> A_3_36 (A_4_4 (x, z), A_32_4 (y, z)) + A_32_4 (A_5_0 (A_4_3 (S, x), y), z) -> A_0_1 (A_3_4 (x, z), A_0_4 (y, z)) + A_32_4 (A_5_1 (A_4_3 (S, x), y), z) -> A_0_2 (A_3_4 (x, z), A_1_4 (y, z)) + A_32_4 (A_5_2 (A_4_3 (S, x), y), z) -> A_0_2 (A_3_4 (x, z), A_2_4 (y, z)) + A_35_4 (A_3_35 (A_4_4 (S, x), y), z) -> A_3_36 (A_4_4 (x, z), A_35_4 (y, z)) + A_35_4 (A_7_0 (A_4_1 (S, x), y), z) -> A_2_1 (A_1_4 (x, z), A_0_4 (y, z)) + A_35_4 (A_7_0 (A_4_2 (S, x), y), z) -> A_2_1 (A_2_4 (x, z), A_0_4 (y, z)) + A_35_4 (A_7_1 (A_4_1 (S, x), y), z) -> A_2_2 (A_1_4 (x, z), A_1_4 (y, z)) + A_35_4 (A_7_1 (A_4_2 (S, x), y), z) -> A_2_2 (A_2_4 (x, z), A_1_4 (y, z)) + A_35_4 (A_7_2 (A_4_1 (S, x), y), z) -> A_2_2 (A_1_4 (x, z), A_2_4 (y, z)) + A_35_4 (A_7_2 (A_4_2 (S, x), y), z) -> A_2_2 (A_2_4 (x, z), A_2_4 (y, z)) + A_0_6 (A_3_4 (A_4_4 (S, x), y), z) -> A_18_18 (A_4_6 (x, z), A_4_6 (y, z)) + A_0_7 (A_3_4 (A_4_4 (S, x), y), z) -> A_18_18 (A_4_7 (x, z), A_4_7 (y, z)) + A_0_8 (A_3_4 (A_4_4 (S, x), y), z) -> A_18_18 (A_4_8 (x, z), A_4_8 (y, z)) + A_0_9 (A_3_4 (A_4_4 (S, x), y), z) -> A_13_13 (A_4_9 (x, z), A_4_9 (y, z)) + A_0_10 (A_3_4 (A_4_4 (S, x), y), z) -> A_18_18 (A_4_10 (x, z), A_4_10 (y, z)) + A_0_11 (A_3_4 (A_4_4 (S, x), y), z) -> A_15_15 (A_4_11 (x, z), A_4_11 (y, z)) + A_0_12 (A_3_4 (A_4_4 (S, x), y), z) -> A_15_15 (A_4_12 (x, z), A_4_12 (y, z)) + A_0_13 (A_3_4 (A_4_4 (S, x), y), z) -> A_18_18 (A_4_13 (x, z), A_4_13 (y, z)) + A_0_14 (A_3_4 (A_4_4 (S, x), y), z) -> A_18_18 (A_4_14 (x, z), A_4_14 (y, z)) + A_0_15 (A_3_4 (A_4_4 (S, x), y), z) -> A_18_18 (A_4_15 (x, z), A_4_15 (y, z)) + A_0_16 (A_3_4 (A_4_4 (S, x), y), z) -> A_18_18 (A_4_16 (x, z), A_4_16 (y, z)) + A_0_17 (A_3_4 (A_4_4 (S, x), y), z) -> A_28_28 (A_4_17 (x, z), A_4_17 (y, z)) + A_0_18 (A_3_4 (A_4_4 (S, x), y), z) -> A_28_28 (A_4_18 (x, z), A_4_18 (y, z)) + A_0_19 (A_3_4 (A_4_4 (S, x), y), z) -> A_23_23 (A_4_19 (x, z), A_4_19 (y, z)) + A_0_20 (A_3_4 (A_4_4 (S, x), y), z) -> A_26_26 (A_4_20 (x, z), A_4_20 (y, z)) + A_0_21 (A_3_4 (A_4_4 (S, x), y), z) -> A_26_26 (A_4_21 (x, z), A_4_21 (y, z)) + A_0_22 (A_3_4 (A_4_4 (S, x), y), z) -> A_28_28 (A_4_22 (x, z), A_4_22 (y, z)) + A_0_23 (A_3_4 (A_4_4 (S, x), y), z) -> A_28_28 (A_4_23 (x, z), A_4_23 (y, z)) + A_0_24 (A_3_4 (A_4_4 (S, x), y), z) -> A_28_28 (A_4_24 (x, z), A_4_24 (y, z)) + A_0_25 (A_3_4 (A_4_4 (S, x), y), z) -> A_28_28 (A_4_25 (x, z), A_4_25 (y, z)) + A_0_26 (A_3_4 (A_4_4 (S, x), y), z) -> A_28_28 (A_4_26 (x, z), A_4_26 (y, z)) + A_0_27 (A_3_4 (A_4_4 (S, x), y), z) -> A_28_28 (A_4_27 (x, z), A_4_27 (y, z)) + A_0_28 (A_3_4 (A_4_4 (S, x), y), z) -> A_28_28 (A_4_28 (x, z), A_4_28 (y, z)) + A_0_29 (A_3_4 (A_4_4 (S, x), y), z) -> A_28_28 (A_4_29 (x, z), A_4_29 (y, z)) + A_0_30 (A_3_4 (A_4_4 (S, x), y), z) -> A_28_28 (A_4_30 (x, z), A_4_30 (y, z)) + A_0_31 (A_3_4 (A_4_4 (S, x), y), z) -> A_28_28 (A_4_31 (x, z), A_4_31 (y, z)) + A_0_32 (A_3_4 (A_4_4 (S, x), y), z) -> A_28_28 (A_4_32 (x, z), A_4_32 (y, z)) + A_0_33 (A_3_4 (A_4_4 (S, x), y), z) -> A_28_28 (A_4_33 (x, z), A_4_33 (y, z)) + A_0_34 (A_3_4 (A_4_4 (S, x), y), z) -> A_28_28 (A_4_34 (x, z), A_4_34 (y, z)) + A_0_35 (A_3_4 (A_4_4 (S, x), y), z) -> A_28_28 (A_4_35 (x, z), A_4_35 (y, z)) + A_0_36 (A_3_4 (A_4_4 (S, x), y), z) -> A_28_28 (A_4_36 (x, z), A_4_36 (y, z)) + A_0_37 (A_3_4 (A_4_4 (S, x), y), z) -> A_28_28 (A_4_37 (x, z), A_4_37 (y, z)) + A_1_6 (A_3_3 (A_4_4 (S, x), y), z) -> A_18_8 (A_4_6 (x, z), A_3_6 (y, z)) + A_1_7 (A_3_3 (A_4_4 (S, x), y), z) -> A_18_10 (A_4_7 (x, z), A_3_7 (y, z)) + A_1_8 (A_3_3 (A_4_4 (S, x), y), z) -> A_18_8 (A_4_8 (x, z), A_3_8 (y, z)) + A_1_10 (A_3_3 (A_4_4 (S, x), y), z) -> A_18_10 (A_4_10 (x, z), A_3_10 (y, z)) + A_1_13 (A_3_3 (A_4_4 (S, x), y), z) -> A_18_14 (A_4_13 (x, z), A_3_13 (y, z)) + A_1_14 (A_3_3 (A_4_4 (S, x), y), z) -> A_18_14 (A_4_14 (x, z), A_3_14 (y, z)) + A_1_15 (A_3_3 (A_4_4 (S, x), y), z) -> A_18_16 (A_4_15 (x, z), A_3_15 (y, z)) + A_1_16 (A_3_3 (A_4_4 (S, x), y), z) -> A_18_16 (A_4_16 (x, z), A_3_16 (y, z)) + A_1_17 (A_3_3 (A_4_4 (S, x), y), z) -> A_28_24 (A_4_17 (x, z), A_3_17 (y, z)) + A_1_18 (A_3_3 (A_4_4 (S, x), y), z) -> A_28_18 (A_4_18 (x, z), A_3_18 (y, z)) + A_1_19 (A_3_3 (A_4_4 (S, x), y), z) -> A_23_19 (A_4_19 (x, z), A_3_19 (y, z)) + A_1_20 (A_3_3 (A_4_4 (S, x), y), z) -> A_26_20 (A_4_20 (x, z), A_3_20 (y, z)) + A_1_21 (A_3_3 (A_4_4 (S, x), y), z) -> A_26_21 (A_4_21 (x, z), A_3_21 (y, z)) + A_1_22 (A_3_3 (A_4_4 (S, x), y), z) -> A_28_22 (A_4_22 (x, z), A_3_22 (y, z)) + A_1_23 (A_3_3 (A_4_4 (S, x), y), z) -> A_28_26 (A_4_23 (x, z), A_3_23 (y, z)) + A_1_24 (A_3_3 (A_4_4 (S, x), y), z) -> A_28_24 (A_4_24 (x, z), A_3_24 (y, z)) + A_1_25 (A_3_3 (A_4_4 (S, x), y), z) -> A_28_25 (A_4_25 (x, z), A_3_25 (y, z)) + A_1_26 (A_3_3 (A_4_4 (S, x), y), z) -> A_28_26 (A_4_26 (x, z), A_3_26 (y, z)) + A_1_27 (A_3_3 (A_4_4 (S, x), y), z) -> A_28_27 (A_4_27 (x, z), A_3_27 (y, z)) + A_1_28 (A_3_3 (A_4_4 (S, x), y), z) -> A_28_28 (A_4_28 (x, z), A_3_28 (y, z)) + A_1_29 (A_3_3 (A_4_4 (S, x), y), z) -> A_28_29 (A_4_29 (x, z), A_3_29 (y, z)) + A_1_30 (A_3_3 (A_4_4 (S, x), y), z) -> A_28_30 (A_4_30 (x, z), A_3_30 (y, z)) + A_1_31 (A_3_3 (A_4_4 (S, x), y), z) -> A_28_31 (A_4_31 (x, z), A_3_31 (y, z)) + A_1_32 (A_3_3 (A_4_4 (S, x), y), z) -> A_28_32 (A_4_32 (x, z), A_3_32 (y, z)) + A_1_33 (A_3_3 (A_4_4 (S, x), y), z) -> A_28_33 (A_4_33 (x, z), A_3_33 (y, z)) + A_1_34 (A_3_3 (A_4_4 (S, x), y), z) -> A_28_34 (A_4_34 (x, z), A_3_34 (y, z)) + A_1_35 (A_3_3 (A_4_4 (S, x), y), z) -> A_28_35 (A_4_35 (x, z), A_3_35 (y, z)) + A_1_36 (A_3_3 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_36 (x, z), A_3_36 (y, z)) + A_1_37 (A_3_3 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_37 (x, z), A_3_37 (y, z)) + A_2_5 (A_3_0 (A_4_4 (S, x), y), z) -> A_11_36 (A_4_5 (x, z), A_0_5 (y, z)) + A_2_5 (A_3_1 (A_4_4 (S, x), y), z) -> A_11_36 (A_4_5 (x, z), A_1_5 (y, z)) + A_2_5 (A_3_2 (A_4_4 (S, x), y), z) -> A_11_37 (A_4_5 (x, z), A_2_5 (y, z)) + A_2_6 (A_3_0 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_6 (x, z), A_0_6 (y, z)) + A_2_6 (A_3_1 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_6 (x, z), A_1_6 (y, z)) + A_2_6 (A_3_2 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_6 (x, z), A_2_6 (y, z)) + A_2_7 (A_3_0 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_7 (x, z), A_0_7 (y, z)) + A_2_7 (A_3_1 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_7 (x, z), A_1_7 (y, z)) + A_2_7 (A_3_2 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_7 (x, z), A_2_7 (y, z)) + A_2_8 (A_3_0 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_8 (x, z), A_0_8 (y, z)) + A_2_8 (A_3_1 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_8 (x, z), A_1_8 (y, z)) + A_2_8 (A_3_2 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_8 (x, z), A_2_8 (y, z)) + A_2_9 (A_3_0 (A_4_4 (S, x), y), z) -> A_13_37 (A_4_9 (x, z), A_0_9 (y, z)) + A_2_9 (A_3_1 (A_4_4 (S, x), y), z) -> A_13_36 (A_4_9 (x, z), A_1_9 (y, z)) + A_2_9 (A_3_2 (A_4_4 (S, x), y), z) -> A_13_37 (A_4_9 (x, z), A_2_9 (y, z)) + A_2_10 (A_3_0 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_10 (x, z), A_0_10 (y, z)) + A_2_10 (A_3_1 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_10 (x, z), A_1_10 (y, z)) + A_2_10 (A_3_2 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_10 (x, z), A_2_10 (y, z)) + A_2_11 (A_3_0 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_11 (x, z), A_0_11 (y, z)) + A_2_11 (A_3_1 (A_4_4 (S, x), y), z) -> A_15_36 (A_4_11 (x, z), A_1_11 (y, z)) + A_2_11 (A_3_2 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_11 (x, z), A_2_11 (y, z)) + A_2_12 (A_3_0 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_12 (x, z), A_0_12 (y, z)) + A_2_12 (A_3_1 (A_4_4 (S, x), y), z) -> A_15_36 (A_4_12 (x, z), A_1_12 (y, z)) + A_2_12 (A_3_2 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_12 (x, z), A_2_12 (y, z)) + A_2_13 (A_3_0 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_13 (x, z), A_0_13 (y, z)) + A_2_13 (A_3_1 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_13 (x, z), A_1_13 (y, z)) + A_2_13 (A_3_2 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_13 (x, z), A_2_13 (y, z)) + A_2_14 (A_3_0 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_14 (x, z), A_0_14 (y, z)) + A_2_14 (A_3_1 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_14 (x, z), A_1_14 (y, z)) + A_2_14 (A_3_2 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_14 (x, z), A_2_14 (y, z)) + A_2_15 (A_3_0 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_15 (x, z), A_0_15 (y, z)) + A_2_15 (A_3_1 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_15 (x, z), A_1_15 (y, z)) + A_2_15 (A_3_2 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_15 (x, z), A_2_15 (y, z)) + A_2_16 (A_3_0 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_16 (x, z), A_0_16 (y, z)) + A_2_16 (A_3_1 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_16 (x, z), A_1_16 (y, z)) + A_2_16 (A_3_2 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_16 (x, z), A_2_16 (y, z)) + A_2_17 (A_3_0 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_17 (x, z), A_0_17 (y, z)) + A_2_17 (A_3_1 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_17 (x, z), A_1_17 (y, z)) + A_2_17 (A_3_2 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_17 (x, z), A_2_17 (y, z)) + A_2_18 (A_3_0 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_18 (x, z), A_0_18 (y, z)) + A_2_18 (A_3_1 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_18 (x, z), A_1_18 (y, z)) + A_2_18 (A_3_2 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_18 (x, z), A_2_18 (y, z)) + A_2_19 (A_3_0 (A_4_4 (S, x), y), z) -> A_23_37 (A_4_19 (x, z), A_0_19 (y, z)) + A_2_19 (A_3_1 (A_4_4 (S, x), y), z) -> A_23_37 (A_4_19 (x, z), A_1_19 (y, z)) + A_2_19 (A_3_2 (A_4_4 (S, x), y), z) -> A_23_37 (A_4_19 (x, z), A_2_19 (y, z)) + A_2_20 (A_3_0 (A_4_4 (S, x), y), z) -> A_26_37 (A_4_20 (x, z), A_0_20 (y, z)) + A_2_20 (A_3_1 (A_4_4 (S, x), y), z) -> A_26_37 (A_4_20 (x, z), A_1_20 (y, z)) + A_2_20 (A_3_2 (A_4_4 (S, x), y), z) -> A_26_37 (A_4_20 (x, z), A_2_20 (y, z)) + A_2_21 (A_3_0 (A_4_4 (S, x), y), z) -> A_26_37 (A_4_21 (x, z), A_0_21 (y, z)) + A_2_21 (A_3_1 (A_4_4 (S, x), y), z) -> A_26_37 (A_4_21 (x, z), A_1_21 (y, z)) + A_2_21 (A_3_2 (A_4_4 (S, x), y), z) -> A_26_37 (A_4_21 (x, z), A_2_21 (y, z)) + A_2_22 (A_3_0 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_22 (x, z), A_0_22 (y, z)) + A_2_22 (A_3_1 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_22 (x, z), A_1_22 (y, z)) + A_2_22 (A_3_2 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_22 (x, z), A_2_22 (y, z)) + A_2_23 (A_3_0 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_23 (x, z), A_0_23 (y, z)) + A_2_23 (A_3_1 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_23 (x, z), A_1_23 (y, z)) + A_2_23 (A_3_2 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_23 (x, z), A_2_23 (y, z)) + A_2_24 (A_3_0 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_24 (x, z), A_0_24 (y, z)) + A_2_24 (A_3_1 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_24 (x, z), A_1_24 (y, z)) + A_2_24 (A_3_2 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_24 (x, z), A_2_24 (y, z)) + A_2_25 (A_3_0 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_25 (x, z), A_0_25 (y, z)) + A_2_25 (A_3_1 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_25 (x, z), A_1_25 (y, z)) + A_2_25 (A_3_2 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_25 (x, z), A_2_25 (y, z)) + A_2_26 (A_3_0 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_26 (x, z), A_0_26 (y, z)) + A_2_26 (A_3_1 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_26 (x, z), A_1_26 (y, z)) + A_2_26 (A_3_2 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_26 (x, z), A_2_26 (y, z)) + A_2_27 (A_3_0 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_27 (x, z), A_0_27 (y, z)) + A_2_27 (A_3_1 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_27 (x, z), A_1_27 (y, z)) + A_2_27 (A_3_2 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_27 (x, z), A_2_27 (y, z)) + A_2_28 (A_3_0 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_28 (x, z), A_0_28 (y, z)) + A_2_28 (A_3_1 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_28 (x, z), A_1_28 (y, z)) + A_2_28 (A_3_2 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_28 (x, z), A_2_28 (y, z)) + A_2_29 (A_3_0 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_29 (x, z), A_0_29 (y, z)) + A_2_29 (A_3_1 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_29 (x, z), A_1_29 (y, z)) + A_2_29 (A_3_2 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_29 (x, z), A_2_29 (y, z)) + A_2_30 (A_3_0 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_30 (x, z), A_0_30 (y, z)) + A_2_30 (A_3_1 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_30 (x, z), A_1_30 (y, z)) + A_2_30 (A_3_2 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_30 (x, z), A_2_30 (y, z)) + A_2_31 (A_3_0 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_31 (x, z), A_0_31 (y, z)) + A_2_31 (A_3_1 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_31 (x, z), A_1_31 (y, z)) + A_2_31 (A_3_2 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_31 (x, z), A_2_31 (y, z)) + A_2_32 (A_3_0 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_32 (x, z), A_0_32 (y, z)) + A_2_32 (A_3_1 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_32 (x, z), A_1_32 (y, z)) + A_2_32 (A_3_2 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_32 (x, z), A_2_32 (y, z)) + A_2_33 (A_3_0 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_33 (x, z), A_0_33 (y, z)) + A_2_33 (A_3_1 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_33 (x, z), A_1_33 (y, z)) + A_2_33 (A_3_2 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_33 (x, z), A_2_33 (y, z)) + A_2_34 (A_3_0 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_34 (x, z), A_0_34 (y, z)) + A_2_34 (A_3_1 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_34 (x, z), A_1_34 (y, z)) + A_2_34 (A_3_2 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_34 (x, z), A_2_34 (y, z)) + A_2_35 (A_3_0 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_35 (x, z), A_0_35 (y, z)) + A_2_35 (A_3_1 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_35 (x, z), A_1_35 (y, z)) + A_2_35 (A_3_2 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_35 (x, z), A_2_35 (y, z)) + A_2_36 (A_3_0 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_36 (x, z), A_0_36 (y, z)) + A_2_36 (A_3_1 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_36 (x, z), A_1_36 (y, z)) + A_2_36 (A_3_2 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_36 (x, z), A_2_36 (y, z)) + A_2_37 (A_3_0 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_37 (x, z), A_0_37 (y, z)) + A_2_37 (A_3_1 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_37 (x, z), A_1_37 (y, z)) + A_2_37 (A_3_2 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_37 (x, z), A_2_37 (y, z)) + A_8_5 (A_3_6 (A_4_4 (S, x), y), z) -> A_11_36 (A_4_5 (x, z), A_6_5 (y, z)) + A_8_5 (A_3_8 (A_4_4 (S, x), y), z) -> A_11_37 (A_4_5 (x, z), A_8_5 (y, z)) + A_8_6 (A_3_6 (A_4_4 (S, x), y), z) -> A_18_36 (A_4_6 (x, z), A_6_6 (y, z)) + A_8_6 (A_3_8 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_6 (x, z), A_8_6 (y, z)) + A_8_7 (A_3_6 (A_4_4 (S, x), y), z) -> A_18_36 (A_4_7 (x, z), A_6_7 (y, z)) + A_8_7 (A_3_8 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_7 (x, z), A_8_7 (y, z)) + A_8_8 (A_3_6 (A_4_4 (S, x), y), z) -> A_18_36 (A_4_8 (x, z), A_6_8 (y, z)) + A_8_8 (A_3_8 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_8 (x, z), A_8_8 (y, z)) + A_8_9 (A_3_6 (A_4_4 (S, x), y), z) -> A_13_36 (A_4_9 (x, z), A_6_9 (y, z)) + A_8_9 (A_3_8 (A_4_4 (S, x), y), z) -> A_13_37 (A_4_9 (x, z), A_8_9 (y, z)) + A_8_10 (A_3_6 (A_4_4 (S, x), y), z) -> A_18_36 (A_4_10 (x, z), A_6_10 (y, z)) + A_8_10 (A_3_8 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_10 (x, z), A_8_10 (y, z)) + A_8_11 (A_3_6 (A_4_4 (S, x), y), z) -> A_15_36 (A_4_11 (x, z), A_6_11 (y, z)) + A_8_11 (A_3_8 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_11 (x, z), A_8_11 (y, z)) + A_8_12 (A_3_6 (A_4_4 (S, x), y), z) -> A_15_36 (A_4_12 (x, z), A_6_12 (y, z)) + A_8_12 (A_3_8 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_12 (x, z), A_8_12 (y, z)) + A_8_13 (A_3_6 (A_4_4 (S, x), y), z) -> A_18_36 (A_4_13 (x, z), A_6_13 (y, z)) + A_8_13 (A_3_8 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_13 (x, z), A_8_13 (y, z)) + A_8_14 (A_3_6 (A_4_4 (S, x), y), z) -> A_18_36 (A_4_14 (x, z), A_6_14 (y, z)) + A_8_14 (A_3_8 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_14 (x, z), A_8_14 (y, z)) + A_8_15 (A_3_6 (A_4_4 (S, x), y), z) -> A_18_36 (A_4_15 (x, z), A_6_15 (y, z)) + A_8_15 (A_3_8 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_15 (x, z), A_8_15 (y, z)) + A_8_16 (A_3_6 (A_4_4 (S, x), y), z) -> A_18_36 (A_4_16 (x, z), A_6_16 (y, z)) + A_8_16 (A_3_8 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_16 (x, z), A_8_16 (y, z)) + A_8_17 (A_3_6 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_17 (x, z), A_6_17 (y, z)) + A_8_17 (A_3_8 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_17 (x, z), A_8_17 (y, z)) + A_8_18 (A_3_6 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_18 (x, z), A_6_18 (y, z)) + A_8_18 (A_3_8 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_18 (x, z), A_8_18 (y, z)) + A_8_19 (A_3_6 (A_4_4 (S, x), y), z) -> A_23_36 (A_4_19 (x, z), A_6_19 (y, z)) + A_8_19 (A_3_8 (A_4_4 (S, x), y), z) -> A_23_37 (A_4_19 (x, z), A_8_19 (y, z)) + A_8_20 (A_3_6 (A_4_4 (S, x), y), z) -> A_26_36 (A_4_20 (x, z), A_6_20 (y, z)) + A_8_20 (A_3_8 (A_4_4 (S, x), y), z) -> A_26_37 (A_4_20 (x, z), A_8_20 (y, z)) + A_8_21 (A_3_6 (A_4_4 (S, x), y), z) -> A_26_36 (A_4_21 (x, z), A_6_21 (y, z)) + A_8_21 (A_3_8 (A_4_4 (S, x), y), z) -> A_26_37 (A_4_21 (x, z), A_8_21 (y, z)) + A_8_22 (A_3_6 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_22 (x, z), A_6_22 (y, z)) + A_8_22 (A_3_8 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_22 (x, z), A_8_22 (y, z)) + A_8_23 (A_3_6 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_23 (x, z), A_6_23 (y, z)) + A_8_23 (A_3_8 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_23 (x, z), A_8_23 (y, z)) + A_8_24 (A_3_6 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_24 (x, z), A_6_24 (y, z)) + A_8_24 (A_3_8 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_24 (x, z), A_8_24 (y, z)) + A_8_25 (A_3_6 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_25 (x, z), A_6_25 (y, z)) + A_8_25 (A_3_8 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_25 (x, z), A_8_25 (y, z)) + A_8_26 (A_3_6 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_26 (x, z), A_6_26 (y, z)) + A_8_26 (A_3_8 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_26 (x, z), A_8_26 (y, z)) + A_8_27 (A_3_6 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_27 (x, z), A_6_27 (y, z)) + A_8_27 (A_3_8 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_27 (x, z), A_8_27 (y, z)) + A_8_28 (A_3_6 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_28 (x, z), A_6_28 (y, z)) + A_8_28 (A_3_8 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_28 (x, z), A_8_28 (y, z)) + A_8_29 (A_3_6 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_29 (x, z), A_6_29 (y, z)) + A_8_29 (A_3_8 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_29 (x, z), A_8_29 (y, z)) + A_8_30 (A_3_6 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_30 (x, z), A_6_30 (y, z)) + A_8_30 (A_3_8 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_30 (x, z), A_8_30 (y, z)) + A_8_31 (A_3_6 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_31 (x, z), A_6_31 (y, z)) + A_8_31 (A_3_8 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_31 (x, z), A_8_31 (y, z)) + A_8_32 (A_3_6 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_32 (x, z), A_6_32 (y, z)) + A_8_32 (A_3_8 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_32 (x, z), A_8_32 (y, z)) + A_8_33 (A_3_6 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_33 (x, z), A_6_33 (y, z)) + A_8_33 (A_3_8 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_33 (x, z), A_8_33 (y, z)) + A_8_34 (A_3_6 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_34 (x, z), A_6_34 (y, z)) + A_8_34 (A_3_8 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_34 (x, z), A_8_34 (y, z)) + A_8_35 (A_3_6 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_35 (x, z), A_6_35 (y, z)) + A_8_35 (A_3_8 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_35 (x, z), A_8_35 (y, z)) + A_8_36 (A_3_6 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_36 (x, z), A_6_36 (y, z)) + A_8_36 (A_3_8 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_36 (x, z), A_8_36 (y, z)) + A_8_37 (A_3_6 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_37 (x, z), A_6_37 (y, z)) + A_8_37 (A_3_8 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_37 (x, z), A_8_37 (y, z)) + A_9_5 (A_3_5 (A_4_4 (S, x), y), z) -> A_11_27 (A_4_5 (x, z), A_5_5 (y, z)) + A_9_5 (A_3_9 (A_4_4 (S, x), y), z) -> A_11_37 (A_4_5 (x, z), A_9_5 (y, z)) + A_9_6 (A_3_5 (A_4_4 (S, x), y), z) -> A_18_33 (A_4_6 (x, z), A_5_6 (y, z)) + A_9_6 (A_3_9 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_6 (x, z), A_9_6 (y, z)) + A_9_7 (A_3_5 (A_4_4 (S, x), y), z) -> A_18_33 (A_4_7 (x, z), A_5_7 (y, z)) + A_9_7 (A_3_9 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_7 (x, z), A_9_7 (y, z)) + A_9_8 (A_3_5 (A_4_4 (S, x), y), z) -> A_18_33 (A_4_8 (x, z), A_5_8 (y, z)) + A_9_8 (A_3_9 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_8 (x, z), A_9_8 (y, z)) + A_9_9 (A_3_5 (A_4_4 (S, x), y), z) -> A_13_33 (A_4_9 (x, z), A_5_9 (y, z)) + A_9_9 (A_3_9 (A_4_4 (S, x), y), z) -> A_13_37 (A_4_9 (x, z), A_9_9 (y, z)) + A_9_10 (A_3_5 (A_4_4 (S, x), y), z) -> A_18_33 (A_4_10 (x, z), A_5_10 (y, z)) + A_9_10 (A_3_9 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_10 (x, z), A_9_10 (y, z)) + A_9_11 (A_3_5 (A_4_4 (S, x), y), z) -> A_15_33 (A_4_11 (x, z), A_5_11 (y, z)) + A_9_11 (A_3_9 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_11 (x, z), A_9_11 (y, z)) + A_9_12 (A_3_5 (A_4_4 (S, x), y), z) -> A_15_33 (A_4_12 (x, z), A_5_12 (y, z)) + A_9_12 (A_3_9 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_12 (x, z), A_9_12 (y, z)) + A_9_13 (A_3_5 (A_4_4 (S, x), y), z) -> A_18_33 (A_4_13 (x, z), A_5_13 (y, z)) + A_9_13 (A_3_9 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_13 (x, z), A_9_13 (y, z)) + A_9_14 (A_3_5 (A_4_4 (S, x), y), z) -> A_18_33 (A_4_14 (x, z), A_5_14 (y, z)) + A_9_14 (A_3_9 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_14 (x, z), A_9_14 (y, z)) + A_9_15 (A_3_5 (A_4_4 (S, x), y), z) -> A_18_33 (A_4_15 (x, z), A_5_15 (y, z)) + A_9_15 (A_3_9 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_15 (x, z), A_9_15 (y, z)) + A_9_16 (A_3_5 (A_4_4 (S, x), y), z) -> A_18_33 (A_4_16 (x, z), A_5_16 (y, z)) + A_9_16 (A_3_9 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_16 (x, z), A_9_16 (y, z)) + A_9_17 (A_3_5 (A_4_4 (S, x), y), z) -> A_28_33 (A_4_17 (x, z), A_5_17 (y, z)) + A_9_17 (A_3_9 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_17 (x, z), A_9_17 (y, z)) + A_9_18 (A_3_5 (A_4_4 (S, x), y), z) -> A_28_33 (A_4_18 (x, z), A_5_18 (y, z)) + A_9_18 (A_3_9 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_18 (x, z), A_9_18 (y, z)) + A_9_19 (A_3_5 (A_4_4 (S, x), y), z) -> A_23_33 (A_4_19 (x, z), A_5_19 (y, z)) + A_9_19 (A_3_9 (A_4_4 (S, x), y), z) -> A_23_37 (A_4_19 (x, z), A_9_19 (y, z)) + A_9_20 (A_3_5 (A_4_4 (S, x), y), z) -> A_26_31 (A_4_20 (x, z), A_5_20 (y, z)) + A_9_20 (A_3_9 (A_4_4 (S, x), y), z) -> A_26_37 (A_4_20 (x, z), A_9_20 (y, z)) + A_9_21 (A_3_5 (A_4_4 (S, x), y), z) -> A_26_31 (A_4_21 (x, z), A_5_21 (y, z)) + A_9_21 (A_3_9 (A_4_4 (S, x), y), z) -> A_26_37 (A_4_21 (x, z), A_9_21 (y, z)) + A_9_22 (A_3_5 (A_4_4 (S, x), y), z) -> A_28_33 (A_4_22 (x, z), A_5_22 (y, z)) + A_9_22 (A_3_9 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_22 (x, z), A_9_22 (y, z)) + A_9_23 (A_3_5 (A_4_4 (S, x), y), z) -> A_28_33 (A_4_23 (x, z), A_5_23 (y, z)) + A_9_23 (A_3_9 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_23 (x, z), A_9_23 (y, z)) + A_9_24 (A_3_5 (A_4_4 (S, x), y), z) -> A_28_33 (A_4_24 (x, z), A_5_24 (y, z)) + A_9_24 (A_3_9 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_24 (x, z), A_9_24 (y, z)) + A_9_25 (A_3_5 (A_4_4 (S, x), y), z) -> A_28_33 (A_4_25 (x, z), A_5_25 (y, z)) + A_9_25 (A_3_9 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_25 (x, z), A_9_25 (y, z)) + A_9_26 (A_3_5 (A_4_4 (S, x), y), z) -> A_28_33 (A_4_26 (x, z), A_5_26 (y, z)) + A_9_26 (A_3_9 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_26 (x, z), A_9_26 (y, z)) + A_9_27 (A_3_5 (A_4_4 (S, x), y), z) -> A_28_33 (A_4_27 (x, z), A_5_27 (y, z)) + A_9_27 (A_3_9 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_27 (x, z), A_9_27 (y, z)) + A_9_28 (A_3_5 (A_4_4 (S, x), y), z) -> A_28_33 (A_4_28 (x, z), A_5_28 (y, z)) + A_9_28 (A_3_9 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_28 (x, z), A_9_28 (y, z)) + A_9_29 (A_3_5 (A_4_4 (S, x), y), z) -> A_28_31 (A_4_29 (x, z), A_5_29 (y, z)) + A_9_29 (A_3_9 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_29 (x, z), A_9_29 (y, z)) + A_9_30 (A_3_5 (A_4_4 (S, x), y), z) -> A_28_31 (A_4_30 (x, z), A_5_30 (y, z)) + A_9_30 (A_3_9 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_30 (x, z), A_9_30 (y, z)) + A_9_31 (A_3_5 (A_4_4 (S, x), y), z) -> A_28_31 (A_4_31 (x, z), A_5_31 (y, z)) + A_9_31 (A_3_9 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_31 (x, z), A_9_31 (y, z)) + A_9_32 (A_3_5 (A_4_4 (S, x), y), z) -> A_28_33 (A_4_32 (x, z), A_5_32 (y, z)) + A_9_32 (A_3_9 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_32 (x, z), A_9_32 (y, z)) + A_9_33 (A_3_5 (A_4_4 (S, x), y), z) -> A_28_33 (A_4_33 (x, z), A_5_33 (y, z)) + A_9_33 (A_3_9 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_33 (x, z), A_9_33 (y, z)) + A_9_34 (A_3_5 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_34 (x, z), A_5_34 (y, z)) + A_9_34 (A_3_9 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_34 (x, z), A_9_34 (y, z)) + A_9_35 (A_3_5 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_35 (x, z), A_5_35 (y, z)) + A_9_35 (A_3_9 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_35 (x, z), A_9_35 (y, z)) + A_9_36 (A_3_5 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_36 (x, z), A_5_36 (y, z)) + A_9_36 (A_3_9 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_36 (x, z), A_9_36 (y, z)) + A_9_37 (A_3_5 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_37 (x, z), A_5_37 (y, z)) + A_9_37 (A_3_9 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_37 (x, z), A_9_37 (y, z)) + A_10_5 (A_3_7 (A_4_4 (S, x), y), z) -> A_11_36 (A_4_5 (x, z), A_7_5 (y, z)) + A_10_5 (A_3_10 (A_4_4 (S, x), y), z) -> A_11_37 (A_4_5 (x, z), A_10_5 (y, z)) + A_10_6 (A_3_7 (A_4_4 (S, x), y), z) -> A_18_36 (A_4_6 (x, z), A_7_6 (y, z)) + A_10_6 (A_3_10 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_6 (x, z), A_10_6 (y, z)) + A_10_7 (A_3_7 (A_4_4 (S, x), y), z) -> A_18_36 (A_4_7 (x, z), A_7_7 (y, z)) + A_10_7 (A_3_10 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_7 (x, z), A_10_7 (y, z)) + A_10_8 (A_3_7 (A_4_4 (S, x), y), z) -> A_18_36 (A_4_8 (x, z), A_7_8 (y, z)) + A_10_8 (A_3_10 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_8 (x, z), A_10_8 (y, z)) + A_10_9 (A_3_7 (A_4_4 (S, x), y), z) -> A_13_36 (A_4_9 (x, z), A_7_9 (y, z)) + A_10_9 (A_3_10 (A_4_4 (S, x), y), z) -> A_13_37 (A_4_9 (x, z), A_10_9 (y, z)) + A_10_10 (A_3_7 (A_4_4 (S, x), y), z) -> A_18_36 (A_4_10 (x, z), A_7_10 (y, z)) + A_10_10 (A_3_10 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_10 (x, z), A_10_10 (y, z)) + A_10_11 (A_3_7 (A_4_4 (S, x), y), z) -> A_15_36 (A_4_11 (x, z), A_7_11 (y, z)) + A_10_11 (A_3_10 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_11 (x, z), A_10_11 (y, z)) + A_10_12 (A_3_7 (A_4_4 (S, x), y), z) -> A_15_36 (A_4_12 (x, z), A_7_12 (y, z)) + A_10_12 (A_3_10 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_12 (x, z), A_10_12 (y, z)) + A_10_13 (A_3_7 (A_4_4 (S, x), y), z) -> A_18_36 (A_4_13 (x, z), A_7_13 (y, z)) + A_10_13 (A_3_10 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_13 (x, z), A_10_13 (y, z)) + A_10_14 (A_3_7 (A_4_4 (S, x), y), z) -> A_18_36 (A_4_14 (x, z), A_7_14 (y, z)) + A_10_14 (A_3_10 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_14 (x, z), A_10_14 (y, z)) + A_10_15 (A_3_7 (A_4_4 (S, x), y), z) -> A_18_36 (A_4_15 (x, z), A_7_15 (y, z)) + A_10_15 (A_3_10 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_15 (x, z), A_10_15 (y, z)) + A_10_16 (A_3_7 (A_4_4 (S, x), y), z) -> A_18_36 (A_4_16 (x, z), A_7_16 (y, z)) + A_10_16 (A_3_10 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_16 (x, z), A_10_16 (y, z)) + A_10_17 (A_3_7 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_17 (x, z), A_7_17 (y, z)) + A_10_17 (A_3_10 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_17 (x, z), A_10_17 (y, z)) + A_10_18 (A_3_7 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_18 (x, z), A_7_18 (y, z)) + A_10_18 (A_3_10 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_18 (x, z), A_10_18 (y, z)) + A_10_19 (A_3_7 (A_4_4 (S, x), y), z) -> A_23_36 (A_4_19 (x, z), A_7_19 (y, z)) + A_10_19 (A_3_10 (A_4_4 (S, x), y), z) -> A_23_37 (A_4_19 (x, z), A_10_19 (y, z)) + A_10_20 (A_3_7 (A_4_4 (S, x), y), z) -> A_26_36 (A_4_20 (x, z), A_7_20 (y, z)) + A_10_20 (A_3_10 (A_4_4 (S, x), y), z) -> A_26_37 (A_4_20 (x, z), A_10_20 (y, z)) + A_10_21 (A_3_7 (A_4_4 (S, x), y), z) -> A_26_36 (A_4_21 (x, z), A_7_21 (y, z)) + A_10_21 (A_3_10 (A_4_4 (S, x), y), z) -> A_26_37 (A_4_21 (x, z), A_10_21 (y, z)) + A_10_22 (A_3_7 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_22 (x, z), A_7_22 (y, z)) + A_10_22 (A_3_10 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_22 (x, z), A_10_22 (y, z)) + A_10_23 (A_3_7 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_23 (x, z), A_7_23 (y, z)) + A_10_23 (A_3_10 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_23 (x, z), A_10_23 (y, z)) + A_10_24 (A_3_7 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_24 (x, z), A_7_24 (y, z)) + A_10_24 (A_3_10 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_24 (x, z), A_10_24 (y, z)) + A_10_25 (A_3_7 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_25 (x, z), A_7_25 (y, z)) + A_10_25 (A_3_10 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_25 (x, z), A_10_25 (y, z)) + A_10_26 (A_3_7 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_26 (x, z), A_7_26 (y, z)) + A_10_26 (A_3_10 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_26 (x, z), A_10_26 (y, z)) + A_10_27 (A_3_7 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_27 (x, z), A_7_27 (y, z)) + A_10_27 (A_3_10 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_27 (x, z), A_10_27 (y, z)) + A_10_28 (A_3_7 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_28 (x, z), A_7_28 (y, z)) + A_10_28 (A_3_10 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_28 (x, z), A_10_28 (y, z)) + A_10_29 (A_3_7 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_29 (x, z), A_7_29 (y, z)) + A_10_29 (A_3_10 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_29 (x, z), A_10_29 (y, z)) + A_10_30 (A_3_7 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_30 (x, z), A_7_30 (y, z)) + A_10_30 (A_3_10 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_30 (x, z), A_10_30 (y, z)) + A_10_31 (A_3_7 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_31 (x, z), A_7_31 (y, z)) + A_10_31 (A_3_10 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_31 (x, z), A_10_31 (y, z)) + A_10_32 (A_3_7 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_32 (x, z), A_7_32 (y, z)) + A_10_32 (A_3_10 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_32 (x, z), A_10_32 (y, z)) + A_10_33 (A_3_7 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_33 (x, z), A_7_33 (y, z)) + A_10_33 (A_3_10 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_33 (x, z), A_10_33 (y, z)) + A_10_34 (A_3_7 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_34 (x, z), A_7_34 (y, z)) + A_10_34 (A_3_10 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_34 (x, z), A_10_34 (y, z)) + A_10_35 (A_3_7 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_35 (x, z), A_7_35 (y, z)) + A_10_35 (A_3_10 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_35 (x, z), A_10_35 (y, z)) + A_10_36 (A_3_7 (A_4_4 (S, x), y), z) -> A_28_36 (A_4_36 (x, z), A_7_36 (y, z)) + A_10_36 (A_3_10 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_36 (x, z), A_10_36 (y, z)) + A_10_37 (A_3_7 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_37 (x, z), A_7_37 (y, z)) + A_10_37 (A_3_10 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_37 (x, z), A_10_37 (y, z)) + A_12_5 (A_3_11 (A_4_4 (S, x), y), z) -> A_11_36 (A_4_5 (x, z), A_11_5 (y, z)) + A_12_5 (A_3_12 (A_4_4 (S, x), y), z) -> A_11_37 (A_4_5 (x, z), A_12_5 (y, z)) + A_12_6 (A_3_11 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_6 (x, z), A_11_6 (y, z)) + A_12_6 (A_3_12 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_6 (x, z), A_12_6 (y, z)) + A_12_7 (A_3_11 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_7 (x, z), A_11_7 (y, z)) + A_12_7 (A_3_12 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_7 (x, z), A_12_7 (y, z)) + A_12_8 (A_3_11 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_8 (x, z), A_11_8 (y, z)) + A_12_8 (A_3_12 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_8 (x, z), A_12_8 (y, z)) + A_12_9 (A_3_11 (A_4_4 (S, x), y), z) -> A_13_36 (A_4_9 (x, z), A_11_9 (y, z)) + A_12_9 (A_3_12 (A_4_4 (S, x), y), z) -> A_13_37 (A_4_9 (x, z), A_12_9 (y, z)) + A_12_10 (A_3_11 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_10 (x, z), A_11_10 (y, z)) + A_12_10 (A_3_12 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_10 (x, z), A_12_10 (y, z)) + A_12_11 (A_3_11 (A_4_4 (S, x), y), z) -> A_15_36 (A_4_11 (x, z), A_11_11 (y, z)) + A_12_11 (A_3_12 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_11 (x, z), A_12_11 (y, z)) + A_12_12 (A_3_11 (A_4_4 (S, x), y), z) -> A_15_36 (A_4_12 (x, z), A_11_12 (y, z)) + A_12_12 (A_3_12 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_12 (x, z), A_12_12 (y, z)) + A_12_13 (A_3_11 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_13 (x, z), A_11_13 (y, z)) + A_12_13 (A_3_12 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_13 (x, z), A_12_13 (y, z)) + A_12_14 (A_3_11 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_14 (x, z), A_11_14 (y, z)) + A_12_14 (A_3_12 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_14 (x, z), A_12_14 (y, z)) + A_12_15 (A_3_11 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_15 (x, z), A_11_15 (y, z)) + A_12_15 (A_3_12 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_15 (x, z), A_12_15 (y, z)) + A_12_16 (A_3_11 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_16 (x, z), A_11_16 (y, z)) + A_12_16 (A_3_12 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_16 (x, z), A_12_16 (y, z)) + A_12_17 (A_3_11 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_17 (x, z), A_11_17 (y, z)) + A_12_17 (A_3_12 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_17 (x, z), A_12_17 (y, z)) + A_12_18 (A_3_11 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_18 (x, z), A_11_18 (y, z)) + A_12_18 (A_3_12 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_18 (x, z), A_12_18 (y, z)) + A_12_19 (A_3_11 (A_4_4 (S, x), y), z) -> A_23_36 (A_4_19 (x, z), A_11_19 (y, z)) + A_12_19 (A_3_12 (A_4_4 (S, x), y), z) -> A_23_37 (A_4_19 (x, z), A_12_19 (y, z)) + A_12_20 (A_3_11 (A_4_4 (S, x), y), z) -> A_26_36 (A_4_20 (x, z), A_11_20 (y, z)) + A_12_20 (A_3_12 (A_4_4 (S, x), y), z) -> A_26_37 (A_4_20 (x, z), A_12_20 (y, z)) + A_12_21 (A_3_11 (A_4_4 (S, x), y), z) -> A_26_36 (A_4_21 (x, z), A_11_21 (y, z)) + A_12_21 (A_3_12 (A_4_4 (S, x), y), z) -> A_26_37 (A_4_21 (x, z), A_12_21 (y, z)) + A_12_22 (A_3_11 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_22 (x, z), A_11_22 (y, z)) + A_12_22 (A_3_12 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_22 (x, z), A_12_22 (y, z)) + A_12_23 (A_3_11 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_23 (x, z), A_11_23 (y, z)) + A_12_23 (A_3_12 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_23 (x, z), A_12_23 (y, z)) + A_12_24 (A_3_11 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_24 (x, z), A_11_24 (y, z)) + A_12_24 (A_3_12 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_24 (x, z), A_12_24 (y, z)) + A_12_25 (A_3_11 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_25 (x, z), A_11_25 (y, z)) + A_12_25 (A_3_12 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_25 (x, z), A_12_25 (y, z)) + A_12_26 (A_3_11 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_26 (x, z), A_11_26 (y, z)) + A_12_26 (A_3_12 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_26 (x, z), A_12_26 (y, z)) + A_12_27 (A_3_11 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_27 (x, z), A_11_27 (y, z)) + A_12_27 (A_3_12 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_27 (x, z), A_12_27 (y, z)) + A_12_28 (A_3_11 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_28 (x, z), A_11_28 (y, z)) + A_12_28 (A_3_12 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_28 (x, z), A_12_28 (y, z)) + A_12_29 (A_3_11 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_29 (x, z), A_11_29 (y, z)) + A_12_29 (A_3_12 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_29 (x, z), A_12_29 (y, z)) + A_12_30 (A_3_11 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_30 (x, z), A_11_30 (y, z)) + A_12_30 (A_3_12 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_30 (x, z), A_12_30 (y, z)) + A_12_31 (A_3_11 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_31 (x, z), A_11_31 (y, z)) + A_12_31 (A_3_12 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_31 (x, z), A_12_31 (y, z)) + A_12_32 (A_3_11 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_32 (x, z), A_11_32 (y, z)) + A_12_32 (A_3_12 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_32 (x, z), A_12_32 (y, z)) + A_12_33 (A_3_11 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_33 (x, z), A_11_33 (y, z)) + A_12_33 (A_3_12 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_33 (x, z), A_12_33 (y, z)) + A_12_34 (A_3_11 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_34 (x, z), A_11_34 (y, z)) + A_12_34 (A_3_12 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_34 (x, z), A_12_34 (y, z)) + A_12_35 (A_3_11 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_35 (x, z), A_11_35 (y, z)) + A_12_35 (A_3_12 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_35 (x, z), A_12_35 (y, z)) + A_12_36 (A_3_11 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_36 (x, z), A_11_36 (y, z)) + A_12_36 (A_3_12 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_36 (x, z), A_12_36 (y, z)) + A_12_37 (A_3_11 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_37 (x, z), A_11_37 (y, z)) + A_12_37 (A_3_12 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_37 (x, z), A_12_37 (y, z)) + A_14_5 (A_3_13 (A_4_4 (S, x), y), z) -> A_11_36 (A_4_5 (x, z), A_13_5 (y, z)) + A_14_5 (A_3_14 (A_4_4 (S, x), y), z) -> A_11_37 (A_4_5 (x, z), A_14_5 (y, z)) + A_14_6 (A_3_13 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_6 (x, z), A_13_6 (y, z)) + A_14_6 (A_3_14 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_6 (x, z), A_14_6 (y, z)) + A_14_7 (A_3_13 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_7 (x, z), A_13_7 (y, z)) + A_14_7 (A_3_14 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_7 (x, z), A_14_7 (y, z)) + A_14_8 (A_3_13 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_8 (x, z), A_13_8 (y, z)) + A_14_8 (A_3_14 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_8 (x, z), A_14_8 (y, z)) + A_14_9 (A_3_13 (A_4_4 (S, x), y), z) -> A_13_36 (A_4_9 (x, z), A_13_9 (y, z)) + A_14_9 (A_3_14 (A_4_4 (S, x), y), z) -> A_13_37 (A_4_9 (x, z), A_14_9 (y, z)) + A_14_10 (A_3_13 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_10 (x, z), A_13_10 (y, z)) + A_14_10 (A_3_14 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_10 (x, z), A_14_10 (y, z)) + A_14_11 (A_3_13 (A_4_4 (S, x), y), z) -> A_15_36 (A_4_11 (x, z), A_13_11 (y, z)) + A_14_11 (A_3_14 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_11 (x, z), A_14_11 (y, z)) + A_14_12 (A_3_13 (A_4_4 (S, x), y), z) -> A_15_36 (A_4_12 (x, z), A_13_12 (y, z)) + A_14_12 (A_3_14 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_12 (x, z), A_14_12 (y, z)) + A_14_13 (A_3_13 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_13 (x, z), A_13_13 (y, z)) + A_14_13 (A_3_14 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_13 (x, z), A_14_13 (y, z)) + A_14_14 (A_3_13 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_14 (x, z), A_13_14 (y, z)) + A_14_14 (A_3_14 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_14 (x, z), A_14_14 (y, z)) + A_14_15 (A_3_13 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_15 (x, z), A_13_15 (y, z)) + A_14_15 (A_3_14 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_15 (x, z), A_14_15 (y, z)) + A_14_16 (A_3_13 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_16 (x, z), A_13_16 (y, z)) + A_14_16 (A_3_14 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_16 (x, z), A_14_16 (y, z)) + A_14_17 (A_3_13 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_17 (x, z), A_13_17 (y, z)) + A_14_17 (A_3_14 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_17 (x, z), A_14_17 (y, z)) + A_14_18 (A_3_13 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_18 (x, z), A_13_18 (y, z)) + A_14_18 (A_3_14 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_18 (x, z), A_14_18 (y, z)) + A_14_19 (A_3_13 (A_4_4 (S, x), y), z) -> A_23_36 (A_4_19 (x, z), A_13_19 (y, z)) + A_14_19 (A_3_14 (A_4_4 (S, x), y), z) -> A_23_37 (A_4_19 (x, z), A_14_19 (y, z)) + A_14_20 (A_3_13 (A_4_4 (S, x), y), z) -> A_26_36 (A_4_20 (x, z), A_13_20 (y, z)) + A_14_20 (A_3_14 (A_4_4 (S, x), y), z) -> A_26_37 (A_4_20 (x, z), A_14_20 (y, z)) + A_14_21 (A_3_13 (A_4_4 (S, x), y), z) -> A_26_36 (A_4_21 (x, z), A_13_21 (y, z)) + A_14_21 (A_3_14 (A_4_4 (S, x), y), z) -> A_26_37 (A_4_21 (x, z), A_14_21 (y, z)) + A_14_22 (A_3_13 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_22 (x, z), A_13_22 (y, z)) + A_14_22 (A_3_14 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_22 (x, z), A_14_22 (y, z)) + A_14_23 (A_3_13 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_23 (x, z), A_13_23 (y, z)) + A_14_23 (A_3_14 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_23 (x, z), A_14_23 (y, z)) + A_14_24 (A_3_13 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_24 (x, z), A_13_24 (y, z)) + A_14_24 (A_3_14 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_24 (x, z), A_14_24 (y, z)) + A_14_25 (A_3_13 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_25 (x, z), A_13_25 (y, z)) + A_14_25 (A_3_14 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_25 (x, z), A_14_25 (y, z)) + A_14_26 (A_3_13 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_26 (x, z), A_13_26 (y, z)) + A_14_26 (A_3_14 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_26 (x, z), A_14_26 (y, z)) + A_14_27 (A_3_13 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_27 (x, z), A_13_27 (y, z)) + A_14_27 (A_3_14 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_27 (x, z), A_14_27 (y, z)) + A_14_28 (A_3_13 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_28 (x, z), A_13_28 (y, z)) + A_14_28 (A_3_14 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_28 (x, z), A_14_28 (y, z)) + A_14_29 (A_3_13 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_29 (x, z), A_13_29 (y, z)) + A_14_29 (A_3_14 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_29 (x, z), A_14_29 (y, z)) + A_14_30 (A_3_13 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_30 (x, z), A_13_30 (y, z)) + A_14_30 (A_3_14 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_30 (x, z), A_14_30 (y, z)) + A_14_31 (A_3_13 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_31 (x, z), A_13_31 (y, z)) + A_14_31 (A_3_14 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_31 (x, z), A_14_31 (y, z)) + A_14_32 (A_3_13 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_32 (x, z), A_13_32 (y, z)) + A_14_32 (A_3_14 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_32 (x, z), A_14_32 (y, z)) + A_14_33 (A_3_13 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_33 (x, z), A_13_33 (y, z)) + A_14_33 (A_3_14 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_33 (x, z), A_14_33 (y, z)) + A_14_34 (A_3_13 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_34 (x, z), A_13_34 (y, z)) + A_14_34 (A_3_14 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_34 (x, z), A_14_34 (y, z)) + A_14_35 (A_3_13 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_35 (x, z), A_13_35 (y, z)) + A_14_35 (A_3_14 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_35 (x, z), A_14_35 (y, z)) + A_14_36 (A_3_13 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_36 (x, z), A_13_36 (y, z)) + A_14_36 (A_3_14 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_36 (x, z), A_14_36 (y, z)) + A_14_37 (A_3_13 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_37 (x, z), A_13_37 (y, z)) + A_14_37 (A_3_14 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_37 (x, z), A_14_37 (y, z)) + A_16_5 (A_3_15 (A_4_4 (S, x), y), z) -> A_11_36 (A_4_5 (x, z), A_15_5 (y, z)) + A_16_5 (A_3_16 (A_4_4 (S, x), y), z) -> A_11_37 (A_4_5 (x, z), A_16_5 (y, z)) + A_16_6 (A_3_15 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_6 (x, z), A_15_6 (y, z)) + A_16_6 (A_3_16 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_6 (x, z), A_16_6 (y, z)) + A_16_7 (A_3_15 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_7 (x, z), A_15_7 (y, z)) + A_16_7 (A_3_16 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_7 (x, z), A_16_7 (y, z)) + A_16_8 (A_3_15 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_8 (x, z), A_15_8 (y, z)) + A_16_8 (A_3_16 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_8 (x, z), A_16_8 (y, z)) + A_16_9 (A_3_15 (A_4_4 (S, x), y), z) -> A_13_36 (A_4_9 (x, z), A_15_9 (y, z)) + A_16_9 (A_3_16 (A_4_4 (S, x), y), z) -> A_13_37 (A_4_9 (x, z), A_16_9 (y, z)) + A_16_10 (A_3_15 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_10 (x, z), A_15_10 (y, z)) + A_16_10 (A_3_16 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_10 (x, z), A_16_10 (y, z)) + A_16_11 (A_3_15 (A_4_4 (S, x), y), z) -> A_15_36 (A_4_11 (x, z), A_15_11 (y, z)) + A_16_11 (A_3_16 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_11 (x, z), A_16_11 (y, z)) + A_16_12 (A_3_15 (A_4_4 (S, x), y), z) -> A_15_36 (A_4_12 (x, z), A_15_12 (y, z)) + A_16_12 (A_3_16 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_12 (x, z), A_16_12 (y, z)) + A_16_13 (A_3_15 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_13 (x, z), A_15_13 (y, z)) + A_16_13 (A_3_16 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_13 (x, z), A_16_13 (y, z)) + A_16_14 (A_3_15 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_14 (x, z), A_15_14 (y, z)) + A_16_14 (A_3_16 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_14 (x, z), A_16_14 (y, z)) + A_16_15 (A_3_15 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_15 (x, z), A_15_15 (y, z)) + A_16_15 (A_3_16 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_15 (x, z), A_16_15 (y, z)) + A_16_16 (A_3_15 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_16 (x, z), A_15_16 (y, z)) + A_16_16 (A_3_16 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_16 (x, z), A_16_16 (y, z)) + A_16_17 (A_3_15 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_17 (x, z), A_15_17 (y, z)) + A_16_17 (A_3_16 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_17 (x, z), A_16_17 (y, z)) + A_16_18 (A_3_15 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_18 (x, z), A_15_18 (y, z)) + A_16_18 (A_3_16 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_18 (x, z), A_16_18 (y, z)) + A_16_19 (A_3_15 (A_4_4 (S, x), y), z) -> A_23_36 (A_4_19 (x, z), A_15_19 (y, z)) + A_16_19 (A_3_16 (A_4_4 (S, x), y), z) -> A_23_37 (A_4_19 (x, z), A_16_19 (y, z)) + A_16_20 (A_3_15 (A_4_4 (S, x), y), z) -> A_26_36 (A_4_20 (x, z), A_15_20 (y, z)) + A_16_20 (A_3_16 (A_4_4 (S, x), y), z) -> A_26_37 (A_4_20 (x, z), A_16_20 (y, z)) + A_16_21 (A_3_15 (A_4_4 (S, x), y), z) -> A_26_36 (A_4_21 (x, z), A_15_21 (y, z)) + A_16_21 (A_3_16 (A_4_4 (S, x), y), z) -> A_26_37 (A_4_21 (x, z), A_16_21 (y, z)) + A_16_22 (A_3_15 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_22 (x, z), A_15_22 (y, z)) + A_16_22 (A_3_16 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_22 (x, z), A_16_22 (y, z)) + A_16_23 (A_3_15 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_23 (x, z), A_15_23 (y, z)) + A_16_23 (A_3_16 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_23 (x, z), A_16_23 (y, z)) + A_16_24 (A_3_15 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_24 (x, z), A_15_24 (y, z)) + A_16_24 (A_3_16 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_24 (x, z), A_16_24 (y, z)) + A_16_25 (A_3_15 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_25 (x, z), A_15_25 (y, z)) + A_16_25 (A_3_16 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_25 (x, z), A_16_25 (y, z)) + A_16_26 (A_3_15 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_26 (x, z), A_15_26 (y, z)) + A_16_26 (A_3_16 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_26 (x, z), A_16_26 (y, z)) + A_16_27 (A_3_15 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_27 (x, z), A_15_27 (y, z)) + A_16_27 (A_3_16 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_27 (x, z), A_16_27 (y, z)) + A_16_28 (A_3_15 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_28 (x, z), A_15_28 (y, z)) + A_16_28 (A_3_16 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_28 (x, z), A_16_28 (y, z)) + A_16_29 (A_3_15 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_29 (x, z), A_15_29 (y, z)) + A_16_29 (A_3_16 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_29 (x, z), A_16_29 (y, z)) + A_16_30 (A_3_15 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_30 (x, z), A_15_30 (y, z)) + A_16_30 (A_3_16 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_30 (x, z), A_16_30 (y, z)) + A_16_31 (A_3_15 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_31 (x, z), A_15_31 (y, z)) + A_16_31 (A_3_16 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_31 (x, z), A_16_31 (y, z)) + A_16_32 (A_3_15 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_32 (x, z), A_15_32 (y, z)) + A_16_32 (A_3_16 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_32 (x, z), A_16_32 (y, z)) + A_16_33 (A_3_15 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_33 (x, z), A_15_33 (y, z)) + A_16_33 (A_3_16 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_33 (x, z), A_16_33 (y, z)) + A_16_34 (A_3_15 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_34 (x, z), A_15_34 (y, z)) + A_16_34 (A_3_16 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_34 (x, z), A_16_34 (y, z)) + A_16_35 (A_3_15 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_35 (x, z), A_15_35 (y, z)) + A_16_35 (A_3_16 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_35 (x, z), A_16_35 (y, z)) + A_16_36 (A_3_15 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_36 (x, z), A_15_36 (y, z)) + A_16_36 (A_3_16 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_36 (x, z), A_16_36 (y, z)) + A_16_37 (A_3_15 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_37 (x, z), A_15_37 (y, z)) + A_16_37 (A_3_16 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_37 (x, z), A_16_37 (y, z)) + A_17_5 (A_5_3 (A_4_3 (S, x), y), z) -> A_9_9 (A_3_5 (x, z), A_3_5 (y, z)) + A_17_6 (A_5_3 (A_4_3 (S, x), y), z) -> A_8_8 (A_3_6 (x, z), A_3_6 (y, z)) + A_17_7 (A_5_3 (A_4_3 (S, x), y), z) -> A_10_10 (A_3_7 (x, z), A_3_7 (y, z)) + A_17_8 (A_5_3 (A_4_3 (S, x), y), z) -> A_8_8 (A_3_8 (x, z), A_3_8 (y, z)) + A_17_9 (A_5_3 (A_4_3 (S, x), y), z) -> A_9_9 (A_3_9 (x, z), A_3_9 (y, z)) + A_17_10 (A_5_3 (A_4_3 (S, x), y), z) -> A_10_10 (A_3_10 (x, z), A_3_10 (y, z)) + A_17_11 (A_5_3 (A_4_3 (S, x), y), z) -> A_12_12 (A_3_11 (x, z), A_3_11 (y, z)) + A_17_12 (A_5_3 (A_4_3 (S, x), y), z) -> A_12_12 (A_3_12 (x, z), A_3_12 (y, z)) + A_17_13 (A_5_3 (A_4_3 (S, x), y), z) -> A_14_14 (A_3_13 (x, z), A_3_13 (y, z)) + A_17_14 (A_5_3 (A_4_3 (S, x), y), z) -> A_14_14 (A_3_14 (x, z), A_3_14 (y, z)) + A_17_15 (A_5_3 (A_4_3 (S, x), y), z) -> A_16_16 (A_3_15 (x, z), A_3_15 (y, z)) + A_17_16 (A_5_3 (A_4_3 (S, x), y), z) -> A_16_16 (A_3_16 (x, z), A_3_16 (y, z)) + A_17_18 (A_5_3 (A_4_3 (S, x), y), z) -> A_18_18 (A_3_18 (x, z), A_3_18 (y, z)) + A_17_19 (A_5_3 (A_4_3 (S, x), y), z) -> A_19_19 (A_3_19 (x, z), A_3_19 (y, z)) + A_17_23 (A_5_3 (A_4_3 (S, x), y), z) -> A_26_26 (A_3_23 (x, z), A_3_23 (y, z)) + A_17_25 (A_5_3 (A_4_3 (S, x), y), z) -> A_25_25 (A_3_25 (x, z), A_3_25 (y, z)) + A_17_26 (A_5_3 (A_4_3 (S, x), y), z) -> A_26_26 (A_3_26 (x, z), A_3_26 (y, z)) + A_17_28 (A_5_3 (A_4_3 (S, x), y), z) -> A_28_28 (A_3_28 (x, z), A_3_28 (y, z)) + A_18_0 (A_3_18 (A_4_4 (S, x), y), z) -> A_6_37 (A_4_0 (x, z), A_18_0 (y, z)) + A_18_1 (A_3_18 (A_4_4 (S, x), y), z) -> A_7_37 (A_4_1 (x, z), A_18_1 (y, z)) + A_18_2 (A_3_18 (A_4_4 (S, x), y), z) -> A_7_37 (A_4_2 (x, z), A_18_2 (y, z)) + A_18_3 (A_3_18 (A_4_4 (S, x), y), z) -> A_5_37 (A_4_3 (x, z), A_18_3 (y, z)) + A_18_5 (A_3_18 (A_4_4 (S, x), y), z) -> A_11_37 (A_4_5 (x, z), A_18_5 (y, z)) + A_18_6 (A_3_18 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_6 (x, z), A_18_6 (y, z)) + A_18_7 (A_3_18 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_7 (x, z), A_18_7 (y, z)) + A_18_8 (A_3_18 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_8 (x, z), A_18_8 (y, z)) + A_18_9 (A_3_18 (A_4_4 (S, x), y), z) -> A_13_37 (A_4_9 (x, z), A_18_9 (y, z)) + A_18_10 (A_3_18 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_10 (x, z), A_18_10 (y, z)) + A_18_11 (A_3_18 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_11 (x, z), A_18_11 (y, z)) + A_18_12 (A_3_18 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_12 (x, z), A_18_12 (y, z)) + A_18_13 (A_3_18 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_13 (x, z), A_18_13 (y, z)) + A_18_14 (A_3_18 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_14 (x, z), A_18_14 (y, z)) + A_18_15 (A_3_18 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_15 (x, z), A_18_15 (y, z)) + A_18_16 (A_3_18 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_16 (x, z), A_18_16 (y, z)) + A_18_17 (A_3_18 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_17 (x, z), A_18_17 (y, z)) + A_18_18 (A_3_18 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_18 (x, z), A_18_18 (y, z)) + A_18_19 (A_3_18 (A_4_4 (S, x), y), z) -> A_23_37 (A_4_19 (x, z), A_18_19 (y, z)) + A_18_20 (A_3_18 (A_4_4 (S, x), y), z) -> A_26_37 (A_4_20 (x, z), A_18_20 (y, z)) + A_18_21 (A_3_18 (A_4_4 (S, x), y), z) -> A_26_37 (A_4_21 (x, z), A_18_21 (y, z)) + A_18_22 (A_3_18 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_22 (x, z), A_18_22 (y, z)) + A_18_23 (A_3_18 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_23 (x, z), A_18_23 (y, z)) + A_18_24 (A_3_18 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_24 (x, z), A_18_24 (y, z)) + A_18_25 (A_3_18 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_25 (x, z), A_18_25 (y, z)) + A_18_26 (A_3_18 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_26 (x, z), A_18_26 (y, z)) + A_18_27 (A_3_18 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_27 (x, z), A_18_27 (y, z)) + A_18_28 (A_3_18 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_28 (x, z), A_18_28 (y, z)) + A_18_29 (A_3_18 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_29 (x, z), A_18_29 (y, z)) + A_18_30 (A_3_18 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_30 (x, z), A_18_30 (y, z)) + A_18_31 (A_3_18 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_31 (x, z), A_18_31 (y, z)) + A_18_32 (A_3_18 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_32 (x, z), A_18_32 (y, z)) + A_18_33 (A_3_18 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_33 (x, z), A_18_33 (y, z)) + A_18_34 (A_3_18 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_34 (x, z), A_18_34 (y, z)) + A_18_35 (A_3_18 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_35 (x, z), A_18_35 (y, z)) + A_18_36 (A_3_18 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_36 (x, z), A_18_36 (y, z)) + A_18_37 (A_3_18 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_37 (x, z), A_18_37 (y, z)) + A_19_0 (A_3_19 (A_4_4 (S, x), y), z) -> A_6_37 (A_4_0 (x, z), A_19_0 (y, z)) + A_19_0 (A_5_4 (A_4_3 (S, x), y), z) -> A_2_6 (A_3_0 (x, z), A_4_0 (y, z)) + A_19_1 (A_3_19 (A_4_4 (S, x), y), z) -> A_7_37 (A_4_1 (x, z), A_19_1 (y, z)) + A_19_1 (A_5_4 (A_4_3 (S, x), y), z) -> A_2_7 (A_3_1 (x, z), A_4_1 (y, z)) + A_19_2 (A_3_19 (A_4_4 (S, x), y), z) -> A_7_37 (A_4_2 (x, z), A_19_2 (y, z)) + A_19_2 (A_5_4 (A_4_3 (S, x), y), z) -> A_2_7 (A_3_2 (x, z), A_4_2 (y, z)) + A_19_5 (A_3_19 (A_4_4 (S, x), y), z) -> A_11_37 (A_4_5 (x, z), A_19_5 (y, z)) + A_19_5 (A_5_4 (A_4_3 (S, x), y), z) -> A_9_11 (A_3_5 (x, z), A_4_5 (y, z)) + A_19_6 (A_3_19 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_6 (x, z), A_19_6 (y, z)) + A_19_6 (A_5_4 (A_4_3 (S, x), y), z) -> A_8_18 (A_3_6 (x, z), A_4_6 (y, z)) + A_19_7 (A_3_19 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_7 (x, z), A_19_7 (y, z)) + A_19_7 (A_5_4 (A_4_3 (S, x), y), z) -> A_10_18 (A_3_7 (x, z), A_4_7 (y, z)) + A_19_8 (A_3_19 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_8 (x, z), A_19_8 (y, z)) + A_19_8 (A_5_4 (A_4_3 (S, x), y), z) -> A_8_18 (A_3_8 (x, z), A_4_8 (y, z)) + A_19_9 (A_3_19 (A_4_4 (S, x), y), z) -> A_13_37 (A_4_9 (x, z), A_19_9 (y, z)) + A_19_9 (A_5_4 (A_4_3 (S, x), y), z) -> A_9_13 (A_3_9 (x, z), A_4_9 (y, z)) + A_19_10 (A_3_19 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_10 (x, z), A_19_10 (y, z)) + A_19_10 (A_5_4 (A_4_3 (S, x), y), z) -> A_10_18 (A_3_10 (x, z), A_4_10 (y, z)) + A_19_11 (A_3_19 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_11 (x, z), A_19_11 (y, z)) + A_19_11 (A_5_4 (A_4_3 (S, x), y), z) -> A_12_15 (A_3_11 (x, z), A_4_11 (y, z)) + A_19_12 (A_3_19 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_12 (x, z), A_19_12 (y, z)) + A_19_12 (A_5_4 (A_4_3 (S, x), y), z) -> A_12_15 (A_3_12 (x, z), A_4_12 (y, z)) + A_19_13 (A_3_19 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_13 (x, z), A_19_13 (y, z)) + A_19_13 (A_5_4 (A_4_3 (S, x), y), z) -> A_14_18 (A_3_13 (x, z), A_4_13 (y, z)) + A_19_14 (A_3_19 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_14 (x, z), A_19_14 (y, z)) + A_19_14 (A_5_4 (A_4_3 (S, x), y), z) -> A_14_18 (A_3_14 (x, z), A_4_14 (y, z)) + A_19_15 (A_3_19 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_15 (x, z), A_19_15 (y, z)) + A_19_15 (A_5_4 (A_4_3 (S, x), y), z) -> A_16_18 (A_3_15 (x, z), A_4_15 (y, z)) + A_19_16 (A_3_19 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_16 (x, z), A_19_16 (y, z)) + A_19_16 (A_5_4 (A_4_3 (S, x), y), z) -> A_16_18 (A_3_16 (x, z), A_4_16 (y, z)) + A_19_17 (A_3_19 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_17 (x, z), A_19_17 (y, z)) + A_19_17 (A_5_4 (A_4_3 (S, x), y), z) -> A_24_28 (A_3_17 (x, z), A_4_17 (y, z)) + A_19_18 (A_3_19 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_18 (x, z), A_19_18 (y, z)) + A_19_18 (A_5_4 (A_4_3 (S, x), y), z) -> A_18_28 (A_3_18 (x, z), A_4_18 (y, z)) + A_19_19 (A_3_19 (A_4_4 (S, x), y), z) -> A_23_37 (A_4_19 (x, z), A_19_19 (y, z)) + A_19_19 (A_5_4 (A_4_3 (S, x), y), z) -> A_19_23 (A_3_19 (x, z), A_4_19 (y, z)) + A_19_22 (A_3_19 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_22 (x, z), A_19_22 (y, z)) + A_19_22 (A_5_4 (A_4_3 (S, x), y), z) -> A_22_28 (A_3_22 (x, z), A_4_22 (y, z)) + A_19_23 (A_3_19 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_23 (x, z), A_19_23 (y, z)) + A_19_23 (A_5_4 (A_4_3 (S, x), y), z) -> A_26_28 (A_3_23 (x, z), A_4_23 (y, z)) + A_19_24 (A_3_19 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_24 (x, z), A_19_24 (y, z)) + A_19_24 (A_5_4 (A_4_3 (S, x), y), z) -> A_24_28 (A_3_24 (x, z), A_4_24 (y, z)) + A_19_25 (A_3_19 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_25 (x, z), A_19_25 (y, z)) + A_19_25 (A_5_4 (A_4_3 (S, x), y), z) -> A_25_28 (A_3_25 (x, z), A_4_25 (y, z)) + A_19_26 (A_3_19 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_26 (x, z), A_19_26 (y, z)) + A_19_26 (A_5_4 (A_4_3 (S, x), y), z) -> A_26_28 (A_3_26 (x, z), A_4_26 (y, z)) + A_19_27 (A_3_19 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_27 (x, z), A_19_27 (y, z)) + A_19_27 (A_5_4 (A_4_3 (S, x), y), z) -> A_27_28 (A_3_27 (x, z), A_4_27 (y, z)) + A_19_28 (A_3_19 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_28 (x, z), A_19_28 (y, z)) + A_19_28 (A_5_4 (A_4_3 (S, x), y), z) -> A_28_28 (A_3_28 (x, z), A_4_28 (y, z)) + A_19_32 (A_3_19 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_32 (x, z), A_19_32 (y, z)) + A_19_32 (A_5_4 (A_4_3 (S, x), y), z) -> A_32_28 (A_3_32 (x, z), A_4_32 (y, z)) + A_19_33 (A_3_19 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_33 (x, z), A_19_33 (y, z)) + A_19_33 (A_5_4 (A_4_3 (S, x), y), z) -> A_33_28 (A_3_33 (x, z), A_4_33 (y, z)) + A_20_3 (A_3_20 (A_4_4 (S, x), y), z) -> A_5_37 (A_4_3 (x, z), A_20_3 (y, z)) + A_20_3 (A_6_4 (A_4_0 (S, x), y), z) -> A_27_5 (A_0_3 (x, z), A_4_3 (y, z)) + A_21_3 (A_3_21 (A_4_4 (S, x), y), z) -> A_5_37 (A_4_3 (x, z), A_21_3 (y, z)) + A_21_3 (A_7_4 (A_4_1 (S, x), y), z) -> A_32_5 (A_1_3 (x, z), A_4_3 (y, z)) + A_21_3 (A_7_4 (A_4_2 (S, x), y), z) -> A_33_5 (A_2_3 (x, z), A_4_3 (y, z)) + A_22_0 (A_3_22 (A_4_4 (S, x), y), z) -> A_6_37 (A_4_0 (x, z), A_22_0 (y, z)) + A_22_0 (A_11_3 (A_4_5 (S, x), y), z) -> A_32_2 (A_5_0 (x, z), A_3_0 (y, z)) + A_22_1 (A_3_22 (A_4_4 (S, x), y), z) -> A_7_37 (A_4_1 (x, z), A_22_1 (y, z)) + A_22_1 (A_11_3 (A_4_5 (S, x), y), z) -> A_32_2 (A_5_1 (x, z), A_3_1 (y, z)) + A_22_2 (A_3_22 (A_4_4 (S, x), y), z) -> A_7_37 (A_4_2 (x, z), A_22_2 (y, z)) + A_22_2 (A_11_3 (A_4_5 (S, x), y), z) -> A_32_2 (A_5_2 (x, z), A_3_2 (y, z)) + A_22_4 (A_3_22 (A_4_4 (S, x), y), z) -> A_3_37 (A_4_4 (x, z), A_22_4 (y, z)) + A_22_4 (A_11_3 (A_4_5 (S, x), y), z) -> A_19_0 (A_5_4 (x, z), A_3_4 (y, z)) + A_22_5 (A_3_22 (A_4_4 (S, x), y), z) -> A_11_37 (A_4_5 (x, z), A_22_5 (y, z)) + A_22_5 (A_11_3 (A_4_5 (S, x), y), z) -> A_27_9 (A_5_5 (x, z), A_3_5 (y, z)) + A_22_6 (A_3_22 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_6 (x, z), A_22_6 (y, z)) + A_22_6 (A_11_3 (A_4_5 (S, x), y), z) -> A_33_8 (A_5_6 (x, z), A_3_6 (y, z)) + A_22_7 (A_3_22 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_7 (x, z), A_22_7 (y, z)) + A_22_7 (A_11_3 (A_4_5 (S, x), y), z) -> A_33_10 (A_5_7 (x, z), A_3_7 (y, z)) + A_22_8 (A_3_22 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_8 (x, z), A_22_8 (y, z)) + A_22_8 (A_11_3 (A_4_5 (S, x), y), z) -> A_33_8 (A_5_8 (x, z), A_3_8 (y, z)) + A_22_9 (A_3_22 (A_4_4 (S, x), y), z) -> A_13_37 (A_4_9 (x, z), A_22_9 (y, z)) + A_22_9 (A_11_3 (A_4_5 (S, x), y), z) -> A_33_9 (A_5_9 (x, z), A_3_9 (y, z)) + A_22_10 (A_3_22 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_10 (x, z), A_22_10 (y, z)) + A_22_10 (A_11_3 (A_4_5 (S, x), y), z) -> A_33_10 (A_5_10 (x, z), A_3_10 (y, z)) + A_22_11 (A_3_22 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_11 (x, z), A_22_11 (y, z)) + A_22_11 (A_11_3 (A_4_5 (S, x), y), z) -> A_33_12 (A_5_11 (x, z), A_3_11 (y, z)) + A_22_12 (A_3_22 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_12 (x, z), A_22_12 (y, z)) + A_22_12 (A_11_3 (A_4_5 (S, x), y), z) -> A_33_12 (A_5_12 (x, z), A_3_12 (y, z)) + A_22_13 (A_3_22 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_13 (x, z), A_22_13 (y, z)) + A_22_13 (A_11_3 (A_4_5 (S, x), y), z) -> A_33_14 (A_5_13 (x, z), A_3_13 (y, z)) + A_22_14 (A_3_22 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_14 (x, z), A_22_14 (y, z)) + A_22_14 (A_11_3 (A_4_5 (S, x), y), z) -> A_33_14 (A_5_14 (x, z), A_3_14 (y, z)) + A_22_15 (A_3_22 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_15 (x, z), A_22_15 (y, z)) + A_22_15 (A_11_3 (A_4_5 (S, x), y), z) -> A_33_16 (A_5_15 (x, z), A_3_15 (y, z)) + A_22_16 (A_3_22 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_16 (x, z), A_22_16 (y, z)) + A_22_16 (A_11_3 (A_4_5 (S, x), y), z) -> A_33_16 (A_5_16 (x, z), A_3_16 (y, z)) + A_22_18 (A_3_22 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_18 (x, z), A_22_18 (y, z)) + A_22_18 (A_11_3 (A_4_5 (S, x), y), z) -> A_33_18 (A_5_18 (x, z), A_3_18 (y, z)) + A_22_23 (A_3_22 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_23 (x, z), A_22_23 (y, z)) + A_22_23 (A_11_3 (A_4_5 (S, x), y), z) -> A_33_26 (A_5_23 (x, z), A_3_23 (y, z)) + A_22_26 (A_3_22 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_26 (x, z), A_22_26 (y, z)) + A_22_26 (A_11_3 (A_4_5 (S, x), y), z) -> A_33_26 (A_5_26 (x, z), A_3_26 (y, z)) + A_22_28 (A_3_22 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_28 (x, z), A_22_28 (y, z)) + A_22_28 (A_11_3 (A_4_5 (S, x), y), z) -> A_33_28 (A_5_28 (x, z), A_3_28 (y, z)) + A_24_5 (A_3_17 (A_4_4 (S, x), y), z) -> A_11_37 (A_4_5 (x, z), A_17_5 (y, z)) + A_24_5 (A_3_24 (A_4_4 (S, x), y), z) -> A_11_37 (A_4_5 (x, z), A_24_5 (y, z)) + A_24_6 (A_3_17 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_6 (x, z), A_17_6 (y, z)) + A_24_6 (A_3_24 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_6 (x, z), A_24_6 (y, z)) + A_24_7 (A_3_17 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_7 (x, z), A_17_7 (y, z)) + A_24_7 (A_3_24 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_7 (x, z), A_24_7 (y, z)) + A_24_8 (A_3_17 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_8 (x, z), A_17_8 (y, z)) + A_24_8 (A_3_24 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_8 (x, z), A_24_8 (y, z)) + A_24_9 (A_3_17 (A_4_4 (S, x), y), z) -> A_13_37 (A_4_9 (x, z), A_17_9 (y, z)) + A_24_9 (A_3_24 (A_4_4 (S, x), y), z) -> A_13_37 (A_4_9 (x, z), A_24_9 (y, z)) + A_24_10 (A_3_17 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_10 (x, z), A_17_10 (y, z)) + A_24_10 (A_3_24 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_10 (x, z), A_24_10 (y, z)) + A_24_11 (A_3_17 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_11 (x, z), A_17_11 (y, z)) + A_24_11 (A_3_24 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_11 (x, z), A_24_11 (y, z)) + A_24_12 (A_3_17 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_12 (x, z), A_17_12 (y, z)) + A_24_12 (A_3_24 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_12 (x, z), A_24_12 (y, z)) + A_24_13 (A_3_17 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_13 (x, z), A_17_13 (y, z)) + A_24_13 (A_3_24 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_13 (x, z), A_24_13 (y, z)) + A_24_14 (A_3_17 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_14 (x, z), A_17_14 (y, z)) + A_24_14 (A_3_24 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_14 (x, z), A_24_14 (y, z)) + A_24_15 (A_3_17 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_15 (x, z), A_17_15 (y, z)) + A_24_15 (A_3_24 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_15 (x, z), A_24_15 (y, z)) + A_24_16 (A_3_17 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_16 (x, z), A_17_16 (y, z)) + A_24_16 (A_3_24 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_16 (x, z), A_24_16 (y, z)) + A_24_18 (A_3_17 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_18 (x, z), A_17_18 (y, z)) + A_24_18 (A_3_24 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_18 (x, z), A_24_18 (y, z)) + A_24_19 (A_3_17 (A_4_4 (S, x), y), z) -> A_23_37 (A_4_19 (x, z), A_17_19 (y, z)) + A_24_19 (A_3_24 (A_4_4 (S, x), y), z) -> A_23_37 (A_4_19 (x, z), A_24_19 (y, z)) + A_24_23 (A_3_17 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_23 (x, z), A_17_23 (y, z)) + A_24_23 (A_3_24 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_23 (x, z), A_24_23 (y, z)) + A_24_25 (A_3_17 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_25 (x, z), A_17_25 (y, z)) + A_24_25 (A_3_24 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_25 (x, z), A_24_25 (y, z)) + A_24_26 (A_3_17 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_26 (x, z), A_17_26 (y, z)) + A_24_26 (A_3_24 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_26 (x, z), A_24_26 (y, z)) + A_24_28 (A_3_17 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_28 (x, z), A_17_28 (y, z)) + A_24_28 (A_3_24 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_28 (x, z), A_24_28 (y, z)) + A_25_0 (A_3_25 (A_4_4 (S, x), y), z) -> A_6_37 (A_4_0 (x, z), A_25_0 (y, z)) + A_25_0 (A_11_4 (A_4_5 (S, x), y), z) -> A_32_6 (A_5_0 (x, z), A_4_0 (y, z)) + A_25_1 (A_3_25 (A_4_4 (S, x), y), z) -> A_7_37 (A_4_1 (x, z), A_25_1 (y, z)) + A_25_1 (A_11_4 (A_4_5 (S, x), y), z) -> A_32_7 (A_5_1 (x, z), A_4_1 (y, z)) + A_25_2 (A_3_25 (A_4_4 (S, x), y), z) -> A_7_37 (A_4_2 (x, z), A_25_2 (y, z)) + A_25_2 (A_11_4 (A_4_5 (S, x), y), z) -> A_32_7 (A_5_2 (x, z), A_4_2 (y, z)) + A_25_3 (A_3_25 (A_4_4 (S, x), y), z) -> A_5_37 (A_4_3 (x, z), A_25_3 (y, z)) + A_25_3 (A_11_4 (A_4_5 (S, x), y), z) -> A_17_5 (A_5_3 (x, z), A_4_3 (y, z)) + A_25_5 (A_3_25 (A_4_4 (S, x), y), z) -> A_11_37 (A_4_5 (x, z), A_25_5 (y, z)) + A_25_5 (A_11_4 (A_4_5 (S, x), y), z) -> A_27_11 (A_5_5 (x, z), A_4_5 (y, z)) + A_25_6 (A_3_25 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_6 (x, z), A_25_6 (y, z)) + A_25_6 (A_11_4 (A_4_5 (S, x), y), z) -> A_33_18 (A_5_6 (x, z), A_4_6 (y, z)) + A_25_7 (A_3_25 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_7 (x, z), A_25_7 (y, z)) + A_25_7 (A_11_4 (A_4_5 (S, x), y), z) -> A_33_18 (A_5_7 (x, z), A_4_7 (y, z)) + A_25_8 (A_3_25 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_8 (x, z), A_25_8 (y, z)) + A_25_8 (A_11_4 (A_4_5 (S, x), y), z) -> A_33_18 (A_5_8 (x, z), A_4_8 (y, z)) + A_25_9 (A_3_25 (A_4_4 (S, x), y), z) -> A_13_37 (A_4_9 (x, z), A_25_9 (y, z)) + A_25_9 (A_11_4 (A_4_5 (S, x), y), z) -> A_33_13 (A_5_9 (x, z), A_4_9 (y, z)) + A_25_10 (A_3_25 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_10 (x, z), A_25_10 (y, z)) + A_25_10 (A_11_4 (A_4_5 (S, x), y), z) -> A_33_18 (A_5_10 (x, z), A_4_10 (y, z)) + A_25_11 (A_3_25 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_11 (x, z), A_25_11 (y, z)) + A_25_11 (A_11_4 (A_4_5 (S, x), y), z) -> A_33_15 (A_5_11 (x, z), A_4_11 (y, z)) + A_25_12 (A_3_25 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_12 (x, z), A_25_12 (y, z)) + A_25_12 (A_11_4 (A_4_5 (S, x), y), z) -> A_33_15 (A_5_12 (x, z), A_4_12 (y, z)) + A_25_13 (A_3_25 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_13 (x, z), A_25_13 (y, z)) + A_25_13 (A_11_4 (A_4_5 (S, x), y), z) -> A_33_18 (A_5_13 (x, z), A_4_13 (y, z)) + A_25_14 (A_3_25 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_14 (x, z), A_25_14 (y, z)) + A_25_14 (A_11_4 (A_4_5 (S, x), y), z) -> A_33_18 (A_5_14 (x, z), A_4_14 (y, z)) + A_25_15 (A_3_25 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_15 (x, z), A_25_15 (y, z)) + A_25_15 (A_11_4 (A_4_5 (S, x), y), z) -> A_33_18 (A_5_15 (x, z), A_4_15 (y, z)) + A_25_16 (A_3_25 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_16 (x, z), A_25_16 (y, z)) + A_25_16 (A_11_4 (A_4_5 (S, x), y), z) -> A_33_18 (A_5_16 (x, z), A_4_16 (y, z)) + A_25_17 (A_3_25 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_17 (x, z), A_25_17 (y, z)) + A_25_17 (A_11_4 (A_4_5 (S, x), y), z) -> A_33_28 (A_5_17 (x, z), A_4_17 (y, z)) + A_25_18 (A_3_25 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_18 (x, z), A_25_18 (y, z)) + A_25_18 (A_11_4 (A_4_5 (S, x), y), z) -> A_33_28 (A_5_18 (x, z), A_4_18 (y, z)) + A_25_19 (A_3_25 (A_4_4 (S, x), y), z) -> A_23_37 (A_4_19 (x, z), A_25_19 (y, z)) + A_25_19 (A_11_4 (A_4_5 (S, x), y), z) -> A_33_23 (A_5_19 (x, z), A_4_19 (y, z)) + A_25_22 (A_3_25 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_22 (x, z), A_25_22 (y, z)) + A_25_22 (A_11_4 (A_4_5 (S, x), y), z) -> A_33_28 (A_5_22 (x, z), A_4_22 (y, z)) + A_25_23 (A_3_25 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_23 (x, z), A_25_23 (y, z)) + A_25_23 (A_11_4 (A_4_5 (S, x), y), z) -> A_33_28 (A_5_23 (x, z), A_4_23 (y, z)) + A_25_24 (A_3_25 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_24 (x, z), A_25_24 (y, z)) + A_25_24 (A_11_4 (A_4_5 (S, x), y), z) -> A_33_28 (A_5_24 (x, z), A_4_24 (y, z)) + A_25_25 (A_3_25 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_25 (x, z), A_25_25 (y, z)) + A_25_25 (A_11_4 (A_4_5 (S, x), y), z) -> A_33_28 (A_5_25 (x, z), A_4_25 (y, z)) + A_25_26 (A_3_25 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_26 (x, z), A_25_26 (y, z)) + A_25_26 (A_11_4 (A_4_5 (S, x), y), z) -> A_33_28 (A_5_26 (x, z), A_4_26 (y, z)) + A_25_27 (A_3_25 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_27 (x, z), A_25_27 (y, z)) + A_25_27 (A_11_4 (A_4_5 (S, x), y), z) -> A_33_28 (A_5_27 (x, z), A_4_27 (y, z)) + A_25_28 (A_3_25 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_28 (x, z), A_25_28 (y, z)) + A_25_28 (A_11_4 (A_4_5 (S, x), y), z) -> A_33_28 (A_5_28 (x, z), A_4_28 (y, z)) + A_25_32 (A_3_25 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_32 (x, z), A_25_32 (y, z)) + A_25_32 (A_11_4 (A_4_5 (S, x), y), z) -> A_33_28 (A_5_32 (x, z), A_4_32 (y, z)) + A_25_33 (A_3_25 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_33 (x, z), A_25_33 (y, z)) + A_25_33 (A_11_4 (A_4_5 (S, x), y), z) -> A_33_28 (A_5_33 (x, z), A_4_33 (y, z)) + A_26_5 (A_3_23 (A_4_4 (S, x), y), z) -> A_11_36 (A_4_5 (x, z), A_23_5 (y, z)) + A_26_5 (A_3_26 (A_4_4 (S, x), y), z) -> A_11_37 (A_4_5 (x, z), A_26_5 (y, z)) + A_26_6 (A_3_23 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_6 (x, z), A_23_6 (y, z)) + A_26_6 (A_3_26 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_6 (x, z), A_26_6 (y, z)) + A_26_7 (A_3_23 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_7 (x, z), A_23_7 (y, z)) + A_26_7 (A_3_26 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_7 (x, z), A_26_7 (y, z)) + A_26_8 (A_3_23 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_8 (x, z), A_23_8 (y, z)) + A_26_8 (A_3_26 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_8 (x, z), A_26_8 (y, z)) + A_26_9 (A_3_23 (A_4_4 (S, x), y), z) -> A_13_36 (A_4_9 (x, z), A_23_9 (y, z)) + A_26_9 (A_3_26 (A_4_4 (S, x), y), z) -> A_13_37 (A_4_9 (x, z), A_26_9 (y, z)) + A_26_10 (A_3_23 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_10 (x, z), A_23_10 (y, z)) + A_26_10 (A_3_26 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_10 (x, z), A_26_10 (y, z)) + A_26_11 (A_3_23 (A_4_4 (S, x), y), z) -> A_15_36 (A_4_11 (x, z), A_23_11 (y, z)) + A_26_11 (A_3_26 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_11 (x, z), A_26_11 (y, z)) + A_26_12 (A_3_23 (A_4_4 (S, x), y), z) -> A_15_36 (A_4_12 (x, z), A_23_12 (y, z)) + A_26_12 (A_3_26 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_12 (x, z), A_26_12 (y, z)) + A_26_13 (A_3_23 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_13 (x, z), A_23_13 (y, z)) + A_26_13 (A_3_26 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_13 (x, z), A_26_13 (y, z)) + A_26_14 (A_3_23 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_14 (x, z), A_23_14 (y, z)) + A_26_14 (A_3_26 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_14 (x, z), A_26_14 (y, z)) + A_26_15 (A_3_23 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_15 (x, z), A_23_15 (y, z)) + A_26_15 (A_3_26 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_15 (x, z), A_26_15 (y, z)) + A_26_16 (A_3_23 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_16 (x, z), A_23_16 (y, z)) + A_26_16 (A_3_26 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_16 (x, z), A_26_16 (y, z)) + A_26_17 (A_3_23 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_17 (x, z), A_23_17 (y, z)) + A_26_17 (A_3_26 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_17 (x, z), A_26_17 (y, z)) + A_26_18 (A_3_23 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_18 (x, z), A_23_18 (y, z)) + A_26_18 (A_3_26 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_18 (x, z), A_26_18 (y, z)) + A_26_19 (A_3_23 (A_4_4 (S, x), y), z) -> A_23_37 (A_4_19 (x, z), A_23_19 (y, z)) + A_26_19 (A_3_26 (A_4_4 (S, x), y), z) -> A_23_37 (A_4_19 (x, z), A_26_19 (y, z)) + A_26_20 (A_3_23 (A_4_4 (S, x), y), z) -> A_26_37 (A_4_20 (x, z), A_23_20 (y, z)) + A_26_20 (A_3_26 (A_4_4 (S, x), y), z) -> A_26_37 (A_4_20 (x, z), A_26_20 (y, z)) + A_26_21 (A_3_23 (A_4_4 (S, x), y), z) -> A_26_37 (A_4_21 (x, z), A_23_21 (y, z)) + A_26_21 (A_3_26 (A_4_4 (S, x), y), z) -> A_26_37 (A_4_21 (x, z), A_26_21 (y, z)) + A_26_22 (A_3_23 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_22 (x, z), A_23_22 (y, z)) + A_26_22 (A_3_26 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_22 (x, z), A_26_22 (y, z)) + A_26_23 (A_3_23 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_23 (x, z), A_23_23 (y, z)) + A_26_23 (A_3_26 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_23 (x, z), A_26_23 (y, z)) + A_26_24 (A_3_23 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_24 (x, z), A_23_24 (y, z)) + A_26_24 (A_3_26 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_24 (x, z), A_26_24 (y, z)) + A_26_25 (A_3_23 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_25 (x, z), A_23_25 (y, z)) + A_26_25 (A_3_26 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_25 (x, z), A_26_25 (y, z)) + A_26_26 (A_3_23 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_26 (x, z), A_23_26 (y, z)) + A_26_26 (A_3_26 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_26 (x, z), A_26_26 (y, z)) + A_26_27 (A_3_23 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_27 (x, z), A_23_27 (y, z)) + A_26_27 (A_3_26 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_27 (x, z), A_26_27 (y, z)) + A_26_28 (A_3_23 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_28 (x, z), A_23_28 (y, z)) + A_26_28 (A_3_26 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_28 (x, z), A_26_28 (y, z)) + A_26_29 (A_3_23 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_29 (x, z), A_23_29 (y, z)) + A_26_29 (A_3_26 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_29 (x, z), A_26_29 (y, z)) + A_26_30 (A_3_23 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_30 (x, z), A_23_30 (y, z)) + A_26_30 (A_3_26 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_30 (x, z), A_26_30 (y, z)) + A_26_31 (A_3_23 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_31 (x, z), A_23_31 (y, z)) + A_26_31 (A_3_26 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_31 (x, z), A_26_31 (y, z)) + A_26_32 (A_3_23 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_32 (x, z), A_23_32 (y, z)) + A_26_32 (A_3_26 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_32 (x, z), A_26_32 (y, z)) + A_26_33 (A_3_23 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_33 (x, z), A_23_33 (y, z)) + A_26_33 (A_3_26 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_33 (x, z), A_26_33 (y, z)) + A_26_34 (A_3_23 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_34 (x, z), A_23_34 (y, z)) + A_26_34 (A_3_26 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_34 (x, z), A_26_34 (y, z)) + A_26_35 (A_3_23 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_35 (x, z), A_23_35 (y, z)) + A_26_35 (A_3_26 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_35 (x, z), A_26_35 (y, z)) + A_26_36 (A_3_23 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_36 (x, z), A_23_36 (y, z)) + A_26_36 (A_3_26 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_36 (x, z), A_26_36 (y, z)) + A_26_37 (A_3_23 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_37 (x, z), A_23_37 (y, z)) + A_26_37 (A_3_26 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_37 (x, z), A_26_37 (y, z)) + A_27_0 (A_3_27 (A_4_4 (S, x), y), z) -> A_6_37 (A_4_0 (x, z), A_27_0 (y, z)) + A_27_0 (A_5_5 (A_4_3 (S, x), y), z) -> A_2_32 (A_3_0 (x, z), A_5_0 (y, z)) + A_27_1 (A_3_27 (A_4_4 (S, x), y), z) -> A_7_37 (A_4_1 (x, z), A_27_1 (y, z)) + A_27_1 (A_5_5 (A_4_3 (S, x), y), z) -> A_2_32 (A_3_1 (x, z), A_5_1 (y, z)) + A_27_2 (A_3_27 (A_4_4 (S, x), y), z) -> A_7_37 (A_4_2 (x, z), A_27_2 (y, z)) + A_27_2 (A_5_5 (A_4_3 (S, x), y), z) -> A_2_32 (A_3_2 (x, z), A_5_2 (y, z)) + A_27_3 (A_3_27 (A_4_4 (S, x), y), z) -> A_5_37 (A_4_3 (x, z), A_27_3 (y, z)) + A_27_3 (A_5_5 (A_4_3 (S, x), y), z) -> A_1_17 (A_3_3 (x, z), A_5_3 (y, z)) + A_27_4 (A_3_27 (A_4_4 (S, x), y), z) -> A_3_37 (A_4_4 (x, z), A_27_4 (y, z)) + A_27_4 (A_5_5 (A_4_3 (S, x), y), z) -> A_0_19 (A_3_4 (x, z), A_5_4 (y, z)) + A_27_5 (A_3_27 (A_4_4 (S, x), y), z) -> A_11_37 (A_4_5 (x, z), A_27_5 (y, z)) + A_27_5 (A_5_5 (A_4_3 (S, x), y), z) -> A_9_27 (A_3_5 (x, z), A_5_5 (y, z)) + A_27_6 (A_3_27 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_6 (x, z), A_27_6 (y, z)) + A_27_6 (A_5_5 (A_4_3 (S, x), y), z) -> A_8_33 (A_3_6 (x, z), A_5_6 (y, z)) + A_27_7 (A_3_27 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_7 (x, z), A_27_7 (y, z)) + A_27_7 (A_5_5 (A_4_3 (S, x), y), z) -> A_10_33 (A_3_7 (x, z), A_5_7 (y, z)) + A_27_8 (A_3_27 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_8 (x, z), A_27_8 (y, z)) + A_27_8 (A_5_5 (A_4_3 (S, x), y), z) -> A_8_33 (A_3_8 (x, z), A_5_8 (y, z)) + A_27_9 (A_3_27 (A_4_4 (S, x), y), z) -> A_13_37 (A_4_9 (x, z), A_27_9 (y, z)) + A_27_9 (A_5_5 (A_4_3 (S, x), y), z) -> A_9_33 (A_3_9 (x, z), A_5_9 (y, z)) + A_27_10 (A_3_27 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_10 (x, z), A_27_10 (y, z)) + A_27_10 (A_5_5 (A_4_3 (S, x), y), z) -> A_10_33 (A_3_10 (x, z), A_5_10 (y, z)) + A_27_11 (A_3_27 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_11 (x, z), A_27_11 (y, z)) + A_27_11 (A_5_5 (A_4_3 (S, x), y), z) -> A_12_33 (A_3_11 (x, z), A_5_11 (y, z)) + A_27_12 (A_3_27 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_12 (x, z), A_27_12 (y, z)) + A_27_12 (A_5_5 (A_4_3 (S, x), y), z) -> A_12_33 (A_3_12 (x, z), A_5_12 (y, z)) + A_27_13 (A_3_27 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_13 (x, z), A_27_13 (y, z)) + A_27_13 (A_5_5 (A_4_3 (S, x), y), z) -> A_14_33 (A_3_13 (x, z), A_5_13 (y, z)) + A_27_14 (A_3_27 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_14 (x, z), A_27_14 (y, z)) + A_27_14 (A_5_5 (A_4_3 (S, x), y), z) -> A_14_33 (A_3_14 (x, z), A_5_14 (y, z)) + A_27_15 (A_3_27 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_15 (x, z), A_27_15 (y, z)) + A_27_15 (A_5_5 (A_4_3 (S, x), y), z) -> A_16_33 (A_3_15 (x, z), A_5_15 (y, z)) + A_27_16 (A_3_27 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_16 (x, z), A_27_16 (y, z)) + A_27_16 (A_5_5 (A_4_3 (S, x), y), z) -> A_16_33 (A_3_16 (x, z), A_5_16 (y, z)) + A_27_18 (A_3_27 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_18 (x, z), A_27_18 (y, z)) + A_27_18 (A_5_5 (A_4_3 (S, x), y), z) -> A_18_33 (A_3_18 (x, z), A_5_18 (y, z)) + A_27_19 (A_3_27 (A_4_4 (S, x), y), z) -> A_23_37 (A_4_19 (x, z), A_27_19 (y, z)) + A_27_19 (A_5_5 (A_4_3 (S, x), y), z) -> A_19_33 (A_3_19 (x, z), A_5_19 (y, z)) + A_27_23 (A_3_27 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_23 (x, z), A_27_23 (y, z)) + A_27_23 (A_5_5 (A_4_3 (S, x), y), z) -> A_26_33 (A_3_23 (x, z), A_5_23 (y, z)) + A_27_25 (A_3_27 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_25 (x, z), A_27_25 (y, z)) + A_27_25 (A_5_5 (A_4_3 (S, x), y), z) -> A_25_33 (A_3_25 (x, z), A_5_25 (y, z)) + A_27_26 (A_3_27 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_26 (x, z), A_27_26 (y, z)) + A_27_26 (A_5_5 (A_4_3 (S, x), y), z) -> A_26_33 (A_3_26 (x, z), A_5_26 (y, z)) + A_27_28 (A_3_27 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_28 (x, z), A_27_28 (y, z)) + A_27_28 (A_5_5 (A_4_3 (S, x), y), z) -> A_28_33 (A_3_28 (x, z), A_5_28 (y, z)) + A_28_0 (A_3_28 (A_4_4 (S, x), y), z) -> A_6_37 (A_4_0 (x, z), A_28_0 (y, z)) + A_28_1 (A_3_28 (A_4_4 (S, x), y), z) -> A_7_37 (A_4_1 (x, z), A_28_1 (y, z)) + A_28_2 (A_3_28 (A_4_4 (S, x), y), z) -> A_7_37 (A_4_2 (x, z), A_28_2 (y, z)) + A_28_3 (A_3_28 (A_4_4 (S, x), y), z) -> A_5_37 (A_4_3 (x, z), A_28_3 (y, z)) + A_28_4 (A_3_28 (A_4_4 (S, x), y), z) -> A_3_37 (A_4_4 (x, z), A_28_4 (y, z)) + A_28_5 (A_3_28 (A_4_4 (S, x), y), z) -> A_11_37 (A_4_5 (x, z), A_28_5 (y, z)) + A_28_6 (A_3_28 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_6 (x, z), A_28_6 (y, z)) + A_28_7 (A_3_28 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_7 (x, z), A_28_7 (y, z)) + A_28_8 (A_3_28 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_8 (x, z), A_28_8 (y, z)) + A_28_9 (A_3_28 (A_4_4 (S, x), y), z) -> A_13_37 (A_4_9 (x, z), A_28_9 (y, z)) + A_28_10 (A_3_28 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_10 (x, z), A_28_10 (y, z)) + A_28_11 (A_3_28 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_11 (x, z), A_28_11 (y, z)) + A_28_12 (A_3_28 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_12 (x, z), A_28_12 (y, z)) + A_28_13 (A_3_28 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_13 (x, z), A_28_13 (y, z)) + A_28_14 (A_3_28 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_14 (x, z), A_28_14 (y, z)) + A_28_15 (A_3_28 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_15 (x, z), A_28_15 (y, z)) + A_28_16 (A_3_28 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_16 (x, z), A_28_16 (y, z)) + A_28_17 (A_3_28 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_17 (x, z), A_28_17 (y, z)) + A_28_18 (A_3_28 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_18 (x, z), A_28_18 (y, z)) + A_28_19 (A_3_28 (A_4_4 (S, x), y), z) -> A_23_37 (A_4_19 (x, z), A_28_19 (y, z)) + A_28_20 (A_3_28 (A_4_4 (S, x), y), z) -> A_26_37 (A_4_20 (x, z), A_28_20 (y, z)) + A_28_21 (A_3_28 (A_4_4 (S, x), y), z) -> A_26_37 (A_4_21 (x, z), A_28_21 (y, z)) + A_28_22 (A_3_28 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_22 (x, z), A_28_22 (y, z)) + A_28_23 (A_3_28 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_23 (x, z), A_28_23 (y, z)) + A_28_24 (A_3_28 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_24 (x, z), A_28_24 (y, z)) + A_28_25 (A_3_28 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_25 (x, z), A_28_25 (y, z)) + A_28_26 (A_3_28 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_26 (x, z), A_28_26 (y, z)) + A_28_27 (A_3_28 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_27 (x, z), A_28_27 (y, z)) + A_28_28 (A_3_28 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_28 (x, z), A_28_28 (y, z)) + A_28_29 (A_3_28 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_29 (x, z), A_28_29 (y, z)) + A_28_30 (A_3_28 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_30 (x, z), A_28_30 (y, z)) + A_28_31 (A_3_28 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_31 (x, z), A_28_31 (y, z)) + A_28_32 (A_3_28 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_32 (x, z), A_28_32 (y, z)) + A_28_33 (A_3_28 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_33 (x, z), A_28_33 (y, z)) + A_28_34 (A_3_28 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_34 (x, z), A_28_34 (y, z)) + A_28_35 (A_3_28 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_35 (x, z), A_28_35 (y, z)) + A_28_36 (A_3_28 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_36 (x, z), A_28_36 (y, z)) + A_28_37 (A_3_28 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_37 (x, z), A_28_37 (y, z)) + A_29_3 (A_3_29 (A_4_4 (S, x), y), z) -> A_5_37 (A_4_3 (x, z), A_29_3 (y, z)) + A_29_3 (A_6_3 (A_4_0 (S, x), y), z) -> A_27_1 (A_0_3 (x, z), A_3_3 (y, z)) + A_30_3 (A_3_30 (A_4_4 (S, x), y), z) -> A_5_37 (A_4_3 (x, z), A_30_3 (y, z)) + A_30_3 (A_7_3 (A_4_1 (S, x), y), z) -> A_32_1 (A_1_3 (x, z), A_3_3 (y, z)) + A_30_3 (A_7_3 (A_4_2 (S, x), y), z) -> A_33_1 (A_2_3 (x, z), A_3_3 (y, z)) + A_30_3 (A_13_4 (A_4_9 (S, x), y), z) -> A_33_5 (A_9_3 (x, z), A_4_3 (y, z)) + A_31_3 (A_3_31 (A_4_4 (S, x), y), z) -> A_5_37 (A_4_3 (x, z), A_31_3 (y, z)) + A_31_3 (A_5_20 (A_4_3 (S, x), y), z) -> A_1_37 (A_3_3 (x, z), A_20_3 (y, z)) + A_31_3 (A_5_21 (A_4_3 (S, x), y), z) -> A_1_37 (A_3_3 (x, z), A_21_3 (y, z)) + A_31_3 (A_5_29 (A_4_3 (S, x), y), z) -> A_1_37 (A_3_3 (x, z), A_29_3 (y, z)) + A_31_3 (A_5_30 (A_4_3 (S, x), y), z) -> A_1_37 (A_3_3 (x, z), A_30_3 (y, z)) + A_31_3 (A_5_31 (A_4_3 (S, x), y), z) -> A_1_37 (A_3_3 (x, z), A_31_3 (y, z)) + A_31_3 (A_13_3 (A_4_9 (S, x), y), z) -> A_33_1 (A_9_3 (x, z), A_3_3 (y, z)) + A_31_3 (A_15_3 (A_4_11 (S, x), y), z) -> A_22_1 (A_11_3 (x, z), A_3_3 (y, z)) + A_31_3 (A_15_3 (A_4_12 (S, x), y), z) -> A_33_1 (A_12_3 (x, z), A_3_3 (y, z)) + A_31_3 (A_15_4 (A_4_11 (S, x), y), z) -> A_22_5 (A_11_3 (x, z), A_4_3 (y, z)) + A_31_3 (A_15_4 (A_4_12 (S, x), y), z) -> A_33_5 (A_12_3 (x, z), A_4_3 (y, z)) + A_31_4 (A_3_31 (A_4_4 (S, x), y), z) -> A_3_37 (A_4_4 (x, z), A_31_4 (y, z)) + A_31_4 (A_5_20 (A_4_3 (S, x), y), z) -> A_0_32 (A_3_4 (x, z), A_20_4 (y, z)) + A_31_4 (A_5_21 (A_4_3 (S, x), y), z) -> A_0_33 (A_3_4 (x, z), A_21_4 (y, z)) + A_31_4 (A_5_29 (A_4_3 (S, x), y), z) -> A_0_34 (A_3_4 (x, z), A_29_4 (y, z)) + A_31_4 (A_5_30 (A_4_3 (S, x), y), z) -> A_0_36 (A_3_4 (x, z), A_30_4 (y, z)) + A_31_4 (A_5_31 (A_4_3 (S, x), y), z) -> A_0_37 (A_3_4 (x, z), A_31_4 (y, z)) + A_31_4 (A_13_3 (A_4_9 (S, x), y), z) -> A_19_0 (A_9_4 (x, z), A_3_4 (y, z)) + A_31_4 (A_15_3 (A_4_11 (S, x), y), z) -> A_25_0 (A_11_4 (x, z), A_3_4 (y, z)) + A_31_4 (A_15_3 (A_4_12 (S, x), y), z) -> A_25_0 (A_12_4 (x, z), A_3_4 (y, z)) + A_31_4 (A_15_4 (A_4_11 (S, x), y), z) -> A_25_3 (A_11_4 (x, z), A_4_4 (y, z)) + A_31_4 (A_15_4 (A_4_12 (S, x), y), z) -> A_25_3 (A_12_4 (x, z), A_4_4 (y, z)) + A_32_0 (A_3_32 (A_4_4 (S, x), y), z) -> A_6_37 (A_4_0 (x, z), A_32_0 (y, z)) + A_32_0 (A_5_0 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_0 (x, z), A_0_0 (y, z)) + A_32_0 (A_5_1 (A_4_3 (S, x), y), z) -> A_2_34 (A_3_0 (x, z), A_1_0 (y, z)) + A_32_0 (A_5_2 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_0 (x, z), A_2_0 (y, z)) + A_32_1 (A_3_32 (A_4_4 (S, x), y), z) -> A_7_37 (A_4_1 (x, z), A_32_1 (y, z)) + A_32_1 (A_5_0 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_1 (x, z), A_0_1 (y, z)) + A_32_1 (A_5_1 (A_4_3 (S, x), y), z) -> A_2_35 (A_3_1 (x, z), A_1_1 (y, z)) + A_32_1 (A_5_2 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_1 (x, z), A_2_1 (y, z)) + A_32_2 (A_3_32 (A_4_4 (S, x), y), z) -> A_7_37 (A_4_2 (x, z), A_32_2 (y, z)) + A_32_2 (A_5_0 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_2 (x, z), A_0_2 (y, z)) + A_32_2 (A_5_1 (A_4_3 (S, x), y), z) -> A_2_35 (A_3_2 (x, z), A_1_2 (y, z)) + A_32_2 (A_5_2 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_2 (x, z), A_2_2 (y, z)) + A_32_3 (A_3_32 (A_4_4 (S, x), y), z) -> A_5_37 (A_4_3 (x, z), A_32_3 (y, z)) + A_32_3 (A_5_0 (A_4_3 (S, x), y), z) -> A_1_27 (A_3_3 (x, z), A_0_3 (y, z)) + A_32_3 (A_5_1 (A_4_3 (S, x), y), z) -> A_1_32 (A_3_3 (x, z), A_1_3 (y, z)) + A_32_3 (A_5_2 (A_4_3 (S, x), y), z) -> A_1_33 (A_3_3 (x, z), A_2_3 (y, z)) + A_32_5 (A_3_32 (A_4_4 (S, x), y), z) -> A_11_37 (A_4_5 (x, z), A_32_5 (y, z)) + A_32_5 (A_5_0 (A_4_3 (S, x), y), z) -> A_9_36 (A_3_5 (x, z), A_0_5 (y, z)) + A_32_5 (A_5_1 (A_4_3 (S, x), y), z) -> A_9_36 (A_3_5 (x, z), A_1_5 (y, z)) + A_32_5 (A_5_2 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_5 (x, z), A_2_5 (y, z)) + A_32_6 (A_3_32 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_6 (x, z), A_32_6 (y, z)) + A_32_6 (A_5_0 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_6 (x, z), A_0_6 (y, z)) + A_32_6 (A_5_1 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_6 (x, z), A_1_6 (y, z)) + A_32_6 (A_5_2 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_6 (x, z), A_2_6 (y, z)) + A_32_7 (A_3_32 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_7 (x, z), A_32_7 (y, z)) + A_32_7 (A_5_0 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_7 (x, z), A_0_7 (y, z)) + A_32_7 (A_5_1 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_7 (x, z), A_1_7 (y, z)) + A_32_7 (A_5_2 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_7 (x, z), A_2_7 (y, z)) + A_32_8 (A_3_32 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_8 (x, z), A_32_8 (y, z)) + A_32_8 (A_5_0 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_8 (x, z), A_0_8 (y, z)) + A_32_8 (A_5_1 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_8 (x, z), A_1_8 (y, z)) + A_32_8 (A_5_2 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_8 (x, z), A_2_8 (y, z)) + A_32_9 (A_3_32 (A_4_4 (S, x), y), z) -> A_13_37 (A_4_9 (x, z), A_32_9 (y, z)) + A_32_9 (A_5_0 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_9 (x, z), A_0_9 (y, z)) + A_32_9 (A_5_1 (A_4_3 (S, x), y), z) -> A_9_36 (A_3_9 (x, z), A_1_9 (y, z)) + A_32_9 (A_5_2 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_9 (x, z), A_2_9 (y, z)) + A_32_10 (A_3_32 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_10 (x, z), A_32_10 (y, z)) + A_32_10 (A_5_0 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_10 (x, z), A_0_10 (y, z)) + A_32_10 (A_5_1 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_10 (x, z), A_1_10 (y, z)) + A_32_10 (A_5_2 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_10 (x, z), A_2_10 (y, z)) + A_32_11 (A_3_32 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_11 (x, z), A_32_11 (y, z)) + A_32_11 (A_5_0 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_11 (x, z), A_0_11 (y, z)) + A_32_11 (A_5_1 (A_4_3 (S, x), y), z) -> A_12_36 (A_3_11 (x, z), A_1_11 (y, z)) + A_32_11 (A_5_2 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_11 (x, z), A_2_11 (y, z)) + A_32_12 (A_3_32 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_12 (x, z), A_32_12 (y, z)) + A_32_12 (A_5_0 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_12 (x, z), A_0_12 (y, z)) + A_32_12 (A_5_1 (A_4_3 (S, x), y), z) -> A_12_36 (A_3_12 (x, z), A_1_12 (y, z)) + A_32_12 (A_5_2 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_12 (x, z), A_2_12 (y, z)) + A_32_13 (A_3_32 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_13 (x, z), A_32_13 (y, z)) + A_32_13 (A_5_0 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_13 (x, z), A_0_13 (y, z)) + A_32_13 (A_5_1 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_13 (x, z), A_1_13 (y, z)) + A_32_13 (A_5_2 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_13 (x, z), A_2_13 (y, z)) + A_32_14 (A_3_32 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_14 (x, z), A_32_14 (y, z)) + A_32_14 (A_5_0 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_14 (x, z), A_0_14 (y, z)) + A_32_14 (A_5_1 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_14 (x, z), A_1_14 (y, z)) + A_32_14 (A_5_2 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_14 (x, z), A_2_14 (y, z)) + A_32_15 (A_3_32 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_15 (x, z), A_32_15 (y, z)) + A_32_15 (A_5_0 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_15 (x, z), A_0_15 (y, z)) + A_32_15 (A_5_1 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_15 (x, z), A_1_15 (y, z)) + A_32_15 (A_5_2 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_15 (x, z), A_2_15 (y, z)) + A_32_16 (A_3_32 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_16 (x, z), A_32_16 (y, z)) + A_32_16 (A_5_0 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_16 (x, z), A_0_16 (y, z)) + A_32_16 (A_5_1 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_16 (x, z), A_1_16 (y, z)) + A_32_16 (A_5_2 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_16 (x, z), A_2_16 (y, z)) + A_32_18 (A_3_32 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_18 (x, z), A_32_18 (y, z)) + A_32_18 (A_5_0 (A_4_3 (S, x), y), z) -> A_18_37 (A_3_18 (x, z), A_0_18 (y, z)) + A_32_18 (A_5_1 (A_4_3 (S, x), y), z) -> A_18_37 (A_3_18 (x, z), A_1_18 (y, z)) + A_32_18 (A_5_2 (A_4_3 (S, x), y), z) -> A_18_37 (A_3_18 (x, z), A_2_18 (y, z)) + A_32_23 (A_3_32 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_23 (x, z), A_32_23 (y, z)) + A_32_23 (A_5_0 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_23 (x, z), A_0_23 (y, z)) + A_32_23 (A_5_1 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_23 (x, z), A_1_23 (y, z)) + A_32_23 (A_5_2 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_23 (x, z), A_2_23 (y, z)) + A_32_26 (A_3_32 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_26 (x, z), A_32_26 (y, z)) + A_32_26 (A_5_0 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_26 (x, z), A_0_26 (y, z)) + A_32_26 (A_5_1 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_26 (x, z), A_1_26 (y, z)) + A_32_26 (A_5_2 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_26 (x, z), A_2_26 (y, z)) + A_32_28 (A_3_32 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_28 (x, z), A_32_28 (y, z)) + A_32_28 (A_5_0 (A_4_3 (S, x), y), z) -> A_28_37 (A_3_28 (x, z), A_0_28 (y, z)) + A_32_28 (A_5_1 (A_4_3 (S, x), y), z) -> A_28_37 (A_3_28 (x, z), A_1_28 (y, z)) + A_32_28 (A_5_2 (A_4_3 (S, x), y), z) -> A_28_37 (A_3_28 (x, z), A_2_28 (y, z)) + A_33_0 (A_3_33 (A_4_4 (S, x), y), z) -> A_6_37 (A_4_0 (x, z), A_33_0 (y, z)) + A_33_0 (A_5_6 (A_4_3 (S, x), y), z) -> A_2_34 (A_3_0 (x, z), A_6_0 (y, z)) + A_33_0 (A_5_7 (A_4_3 (S, x), y), z) -> A_2_35 (A_3_0 (x, z), A_7_0 (y, z)) + A_33_0 (A_5_8 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_0 (x, z), A_8_0 (y, z)) + A_33_0 (A_5_9 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_0 (x, z), A_9_0 (y, z)) + A_33_0 (A_5_10 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_0 (x, z), A_10_0 (y, z)) + A_33_0 (A_5_11 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_0 (x, z), A_11_0 (y, z)) + A_33_0 (A_5_12 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_0 (x, z), A_12_0 (y, z)) + A_33_0 (A_5_13 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_0 (x, z), A_13_0 (y, z)) + A_33_0 (A_5_14 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_0 (x, z), A_14_0 (y, z)) + A_33_0 (A_5_15 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_0 (x, z), A_15_0 (y, z)) + A_33_0 (A_5_16 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_0 (x, z), A_16_0 (y, z)) + A_33_0 (A_5_17 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_0 (x, z), A_17_0 (y, z)) + A_33_0 (A_5_18 (A_4_3 (S, x), y), z) -> A_2_37 (A_3_0 (x, z), A_18_0 (y, z)) + A_33_0 (A_5_19 (A_4_3 (S, x), y), z) -> A_2_37 (A_3_0 (x, z), A_19_0 (y, z)) + A_33_0 (A_5_22 (A_4_3 (S, x), y), z) -> A_2_37 (A_3_0 (x, z), A_22_0 (y, z)) + A_33_0 (A_5_23 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_0 (x, z), A_23_0 (y, z)) + A_33_0 (A_5_24 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_0 (x, z), A_24_0 (y, z)) + A_33_0 (A_5_25 (A_4_3 (S, x), y), z) -> A_2_37 (A_3_0 (x, z), A_25_0 (y, z)) + A_33_0 (A_5_26 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_0 (x, z), A_26_0 (y, z)) + A_33_0 (A_5_27 (A_4_3 (S, x), y), z) -> A_2_37 (A_3_0 (x, z), A_27_0 (y, z)) + A_33_0 (A_5_28 (A_4_3 (S, x), y), z) -> A_2_37 (A_3_0 (x, z), A_28_0 (y, z)) + A_33_0 (A_5_32 (A_4_3 (S, x), y), z) -> A_2_37 (A_3_0 (x, z), A_32_0 (y, z)) + A_33_0 (A_5_33 (A_4_3 (S, x), y), z) -> A_2_37 (A_3_0 (x, z), A_33_0 (y, z)) + A_33_1 (A_3_33 (A_4_4 (S, x), y), z) -> A_7_37 (A_4_1 (x, z), A_33_1 (y, z)) + A_33_1 (A_5_6 (A_4_3 (S, x), y), z) -> A_2_34 (A_3_1 (x, z), A_6_1 (y, z)) + A_33_1 (A_5_7 (A_4_3 (S, x), y), z) -> A_2_35 (A_3_1 (x, z), A_7_1 (y, z)) + A_33_1 (A_5_8 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_1 (x, z), A_8_1 (y, z)) + A_33_1 (A_5_9 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_1 (x, z), A_9_1 (y, z)) + A_33_1 (A_5_10 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_1 (x, z), A_10_1 (y, z)) + A_33_1 (A_5_11 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_1 (x, z), A_11_1 (y, z)) + A_33_1 (A_5_12 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_1 (x, z), A_12_1 (y, z)) + A_33_1 (A_5_13 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_1 (x, z), A_13_1 (y, z)) + A_33_1 (A_5_14 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_1 (x, z), A_14_1 (y, z)) + A_33_1 (A_5_15 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_1 (x, z), A_15_1 (y, z)) + A_33_1 (A_5_16 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_1 (x, z), A_16_1 (y, z)) + A_33_1 (A_5_17 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_1 (x, z), A_17_1 (y, z)) + A_33_1 (A_5_18 (A_4_3 (S, x), y), z) -> A_2_37 (A_3_1 (x, z), A_18_1 (y, z)) + A_33_1 (A_5_19 (A_4_3 (S, x), y), z) -> A_2_37 (A_3_1 (x, z), A_19_1 (y, z)) + A_33_1 (A_5_22 (A_4_3 (S, x), y), z) -> A_2_37 (A_3_1 (x, z), A_22_1 (y, z)) + A_33_1 (A_5_23 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_1 (x, z), A_23_1 (y, z)) + A_33_1 (A_5_24 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_1 (x, z), A_24_1 (y, z)) + A_33_1 (A_5_25 (A_4_3 (S, x), y), z) -> A_2_37 (A_3_1 (x, z), A_25_1 (y, z)) + A_33_1 (A_5_26 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_1 (x, z), A_26_1 (y, z)) + A_33_1 (A_5_27 (A_4_3 (S, x), y), z) -> A_2_37 (A_3_1 (x, z), A_27_1 (y, z)) + A_33_1 (A_5_28 (A_4_3 (S, x), y), z) -> A_2_37 (A_3_1 (x, z), A_28_1 (y, z)) + A_33_1 (A_5_32 (A_4_3 (S, x), y), z) -> A_2_37 (A_3_1 (x, z), A_32_1 (y, z)) + A_33_1 (A_5_33 (A_4_3 (S, x), y), z) -> A_2_37 (A_3_1 (x, z), A_33_1 (y, z)) + A_33_2 (A_3_33 (A_4_4 (S, x), y), z) -> A_7_37 (A_4_2 (x, z), A_33_2 (y, z)) + A_33_2 (A_5_6 (A_4_3 (S, x), y), z) -> A_2_34 (A_3_2 (x, z), A_6_2 (y, z)) + A_33_2 (A_5_7 (A_4_3 (S, x), y), z) -> A_2_35 (A_3_2 (x, z), A_7_2 (y, z)) + A_33_2 (A_5_8 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_2 (x, z), A_8_2 (y, z)) + A_33_2 (A_5_9 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_2 (x, z), A_9_2 (y, z)) + A_33_2 (A_5_10 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_2 (x, z), A_10_2 (y, z)) + A_33_2 (A_5_11 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_2 (x, z), A_11_2 (y, z)) + A_33_2 (A_5_12 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_2 (x, z), A_12_2 (y, z)) + A_33_2 (A_5_13 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_2 (x, z), A_13_2 (y, z)) + A_33_2 (A_5_14 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_2 (x, z), A_14_2 (y, z)) + A_33_2 (A_5_15 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_2 (x, z), A_15_2 (y, z)) + A_33_2 (A_5_16 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_2 (x, z), A_16_2 (y, z)) + A_33_2 (A_5_17 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_2 (x, z), A_17_2 (y, z)) + A_33_2 (A_5_18 (A_4_3 (S, x), y), z) -> A_2_37 (A_3_2 (x, z), A_18_2 (y, z)) + A_33_2 (A_5_19 (A_4_3 (S, x), y), z) -> A_2_37 (A_3_2 (x, z), A_19_2 (y, z)) + A_33_2 (A_5_22 (A_4_3 (S, x), y), z) -> A_2_37 (A_3_2 (x, z), A_22_2 (y, z)) + A_33_2 (A_5_23 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_2 (x, z), A_23_2 (y, z)) + A_33_2 (A_5_24 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_2 (x, z), A_24_2 (y, z)) + A_33_2 (A_5_25 (A_4_3 (S, x), y), z) -> A_2_37 (A_3_2 (x, z), A_25_2 (y, z)) + A_33_2 (A_5_26 (A_4_3 (S, x), y), z) -> A_2_36 (A_3_2 (x, z), A_26_2 (y, z)) + A_33_2 (A_5_27 (A_4_3 (S, x), y), z) -> A_2_37 (A_3_2 (x, z), A_27_2 (y, z)) + A_33_2 (A_5_28 (A_4_3 (S, x), y), z) -> A_2_37 (A_3_2 (x, z), A_28_2 (y, z)) + A_33_2 (A_5_32 (A_4_3 (S, x), y), z) -> A_2_37 (A_3_2 (x, z), A_32_2 (y, z)) + A_33_2 (A_5_33 (A_4_3 (S, x), y), z) -> A_2_37 (A_3_2 (x, z), A_33_2 (y, z)) + A_33_3 (A_3_33 (A_4_4 (S, x), y), z) -> A_5_37 (A_4_3 (x, z), A_33_3 (y, z)) + A_33_3 (A_5_6 (A_4_3 (S, x), y), z) -> A_1_29 (A_3_3 (x, z), A_6_3 (y, z)) + A_33_3 (A_5_7 (A_4_3 (S, x), y), z) -> A_1_30 (A_3_3 (x, z), A_7_3 (y, z)) + A_33_3 (A_5_8 (A_4_3 (S, x), y), z) -> A_1_31 (A_3_3 (x, z), A_8_3 (y, z)) + A_33_3 (A_5_9 (A_4_3 (S, x), y), z) -> A_1_33 (A_3_3 (x, z), A_9_3 (y, z)) + A_33_3 (A_5_10 (A_4_3 (S, x), y), z) -> A_1_31 (A_3_3 (x, z), A_10_3 (y, z)) + A_33_3 (A_5_11 (A_4_3 (S, x), y), z) -> A_1_22 (A_3_3 (x, z), A_11_3 (y, z)) + A_33_3 (A_5_12 (A_4_3 (S, x), y), z) -> A_1_33 (A_3_3 (x, z), A_12_3 (y, z)) + A_33_3 (A_5_13 (A_4_3 (S, x), y), z) -> A_1_31 (A_3_3 (x, z), A_13_3 (y, z)) + A_33_3 (A_5_14 (A_4_3 (S, x), y), z) -> A_1_31 (A_3_3 (x, z), A_14_3 (y, z)) + A_33_3 (A_5_15 (A_4_3 (S, x), y), z) -> A_1_31 (A_3_3 (x, z), A_15_3 (y, z)) + A_33_3 (A_5_16 (A_4_3 (S, x), y), z) -> A_1_31 (A_3_3 (x, z), A_16_3 (y, z)) + A_33_3 (A_5_17 (A_4_3 (S, x), y), z) -> A_1_35 (A_3_3 (x, z), A_17_3 (y, z)) + A_33_3 (A_5_18 (A_4_3 (S, x), y), z) -> A_1_37 (A_3_3 (x, z), A_18_3 (y, z)) + A_33_3 (A_5_19 (A_4_3 (S, x), y), z) -> A_1_36 (A_3_3 (x, z), A_19_3 (y, z)) + A_33_3 (A_5_22 (A_4_3 (S, x), y), z) -> A_1_36 (A_3_3 (x, z), A_22_3 (y, z)) + A_33_3 (A_5_23 (A_4_3 (S, x), y), z) -> A_1_36 (A_3_3 (x, z), A_23_3 (y, z)) + A_33_3 (A_5_24 (A_4_3 (S, x), y), z) -> A_1_36 (A_3_3 (x, z), A_24_3 (y, z)) + A_33_3 (A_5_25 (A_4_3 (S, x), y), z) -> A_1_37 (A_3_3 (x, z), A_25_3 (y, z)) + A_33_3 (A_5_26 (A_4_3 (S, x), y), z) -> A_1_36 (A_3_3 (x, z), A_26_3 (y, z)) + A_33_3 (A_5_27 (A_4_3 (S, x), y), z) -> A_1_37 (A_3_3 (x, z), A_27_3 (y, z)) + A_33_3 (A_5_28 (A_4_3 (S, x), y), z) -> A_1_37 (A_3_3 (x, z), A_28_3 (y, z)) + A_33_3 (A_5_32 (A_4_3 (S, x), y), z) -> A_1_37 (A_3_3 (x, z), A_32_3 (y, z)) + A_33_3 (A_5_33 (A_4_3 (S, x), y), z) -> A_1_37 (A_3_3 (x, z), A_33_3 (y, z)) + A_33_4 (A_3_33 (A_4_4 (S, x), y), z) -> A_3_37 (A_4_4 (x, z), A_33_4 (y, z)) + A_33_4 (A_5_6 (A_4_3 (S, x), y), z) -> A_0_20 (A_3_4 (x, z), A_6_4 (y, z)) + A_33_4 (A_5_7 (A_4_3 (S, x), y), z) -> A_0_21 (A_3_4 (x, z), A_7_4 (y, z)) + A_33_4 (A_5_8 (A_4_3 (S, x), y), z) -> A_0_20 (A_3_4 (x, z), A_8_4 (y, z)) + A_33_4 (A_5_9 (A_4_3 (S, x), y), z) -> A_0_19 (A_3_4 (x, z), A_9_4 (y, z)) + A_33_4 (A_5_10 (A_4_3 (S, x), y), z) -> A_0_21 (A_3_4 (x, z), A_10_4 (y, z)) + A_33_4 (A_5_11 (A_4_3 (S, x), y), z) -> A_0_25 (A_3_4 (x, z), A_11_4 (y, z)) + A_33_4 (A_5_12 (A_4_3 (S, x), y), z) -> A_0_25 (A_3_4 (x, z), A_12_4 (y, z)) + A_33_4 (A_5_13 (A_4_3 (S, x), y), z) -> A_0_30 (A_3_4 (x, z), A_13_4 (y, z)) + A_33_4 (A_5_14 (A_4_3 (S, x), y), z) -> A_0_30 (A_3_4 (x, z), A_14_4 (y, z)) + A_33_4 (A_5_15 (A_4_3 (S, x), y), z) -> A_0_31 (A_3_4 (x, z), A_15_4 (y, z)) + A_33_4 (A_5_16 (A_4_3 (S, x), y), z) -> A_0_31 (A_3_4 (x, z), A_16_4 (y, z)) + A_33_4 (A_5_17 (A_4_3 (S, x), y), z) -> A_0_36 (A_3_4 (x, z), A_17_4 (y, z)) + A_33_4 (A_5_18 (A_4_3 (S, x), y), z) -> A_0_36 (A_3_4 (x, z), A_18_4 (y, z)) + A_33_4 (A_5_19 (A_4_3 (S, x), y), z) -> A_0_27 (A_3_4 (x, z), A_19_4 (y, z)) + A_33_4 (A_5_22 (A_4_3 (S, x), y), z) -> A_0_37 (A_3_4 (x, z), A_22_4 (y, z)) + A_33_4 (A_5_23 (A_4_3 (S, x), y), z) -> A_0_36 (A_3_4 (x, z), A_23_4 (y, z)) + A_33_4 (A_5_24 (A_4_3 (S, x), y), z) -> A_0_36 (A_3_4 (x, z), A_24_4 (y, z)) + A_33_4 (A_5_25 (A_4_3 (S, x), y), z) -> A_0_36 (A_3_4 (x, z), A_25_4 (y, z)) + A_33_4 (A_5_26 (A_4_3 (S, x), y), z) -> A_0_36 (A_3_4 (x, z), A_26_4 (y, z)) + A_33_4 (A_5_27 (A_4_3 (S, x), y), z) -> A_0_37 (A_3_4 (x, z), A_27_4 (y, z)) + A_33_4 (A_5_28 (A_4_3 (S, x), y), z) -> A_0_37 (A_3_4 (x, z), A_28_4 (y, z)) + A_33_4 (A_5_32 (A_4_3 (S, x), y), z) -> A_0_36 (A_3_4 (x, z), A_32_4 (y, z)) + A_33_4 (A_5_33 (A_4_3 (S, x), y), z) -> A_0_37 (A_3_4 (x, z), A_33_4 (y, z)) + A_33_5 (A_3_33 (A_4_4 (S, x), y), z) -> A_11_37 (A_4_5 (x, z), A_33_5 (y, z)) + A_33_5 (A_5_6 (A_4_3 (S, x), y), z) -> A_9_36 (A_3_5 (x, z), A_6_5 (y, z)) + A_33_5 (A_5_7 (A_4_3 (S, x), y), z) -> A_9_36 (A_3_5 (x, z), A_7_5 (y, z)) + A_33_5 (A_5_8 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_5 (x, z), A_8_5 (y, z)) + A_33_5 (A_5_9 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_5 (x, z), A_9_5 (y, z)) + A_33_5 (A_5_10 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_5 (x, z), A_10_5 (y, z)) + A_33_5 (A_5_11 (A_4_3 (S, x), y), z) -> A_9_36 (A_3_5 (x, z), A_11_5 (y, z)) + A_33_5 (A_5_12 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_5 (x, z), A_12_5 (y, z)) + A_33_5 (A_5_13 (A_4_3 (S, x), y), z) -> A_9_36 (A_3_5 (x, z), A_13_5 (y, z)) + A_33_5 (A_5_14 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_5 (x, z), A_14_5 (y, z)) + A_33_5 (A_5_15 (A_4_3 (S, x), y), z) -> A_9_36 (A_3_5 (x, z), A_15_5 (y, z)) + A_33_5 (A_5_16 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_5 (x, z), A_16_5 (y, z)) + A_33_5 (A_5_17 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_5 (x, z), A_17_5 (y, z)) + A_33_5 (A_5_18 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_5 (x, z), A_18_5 (y, z)) + A_33_5 (A_5_19 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_5 (x, z), A_19_5 (y, z)) + A_33_5 (A_5_22 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_5 (x, z), A_22_5 (y, z)) + A_33_5 (A_5_23 (A_4_3 (S, x), y), z) -> A_9_36 (A_3_5 (x, z), A_23_5 (y, z)) + A_33_5 (A_5_24 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_5 (x, z), A_24_5 (y, z)) + A_33_5 (A_5_25 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_5 (x, z), A_25_5 (y, z)) + A_33_5 (A_5_26 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_5 (x, z), A_26_5 (y, z)) + A_33_5 (A_5_27 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_5 (x, z), A_27_5 (y, z)) + A_33_5 (A_5_28 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_5 (x, z), A_28_5 (y, z)) + A_33_5 (A_5_32 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_5 (x, z), A_32_5 (y, z)) + A_33_5 (A_5_33 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_5 (x, z), A_33_5 (y, z)) + A_33_6 (A_3_33 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_6 (x, z), A_33_6 (y, z)) + A_33_6 (A_5_6 (A_4_3 (S, x), y), z) -> A_8_36 (A_3_6 (x, z), A_6_6 (y, z)) + A_33_6 (A_5_7 (A_4_3 (S, x), y), z) -> A_8_36 (A_3_6 (x, z), A_7_6 (y, z)) + A_33_6 (A_5_8 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_6 (x, z), A_8_6 (y, z)) + A_33_6 (A_5_9 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_6 (x, z), A_9_6 (y, z)) + A_33_6 (A_5_10 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_6 (x, z), A_10_6 (y, z)) + A_33_6 (A_5_11 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_6 (x, z), A_11_6 (y, z)) + A_33_6 (A_5_12 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_6 (x, z), A_12_6 (y, z)) + A_33_6 (A_5_13 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_6 (x, z), A_13_6 (y, z)) + A_33_6 (A_5_14 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_6 (x, z), A_14_6 (y, z)) + A_33_6 (A_5_15 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_6 (x, z), A_15_6 (y, z)) + A_33_6 (A_5_16 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_6 (x, z), A_16_6 (y, z)) + A_33_6 (A_5_17 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_6 (x, z), A_17_6 (y, z)) + A_33_6 (A_5_18 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_6 (x, z), A_18_6 (y, z)) + A_33_6 (A_5_19 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_6 (x, z), A_19_6 (y, z)) + A_33_6 (A_5_22 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_6 (x, z), A_22_6 (y, z)) + A_33_6 (A_5_23 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_6 (x, z), A_23_6 (y, z)) + A_33_6 (A_5_24 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_6 (x, z), A_24_6 (y, z)) + A_33_6 (A_5_25 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_6 (x, z), A_25_6 (y, z)) + A_33_6 (A_5_26 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_6 (x, z), A_26_6 (y, z)) + A_33_6 (A_5_27 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_6 (x, z), A_27_6 (y, z)) + A_33_6 (A_5_28 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_6 (x, z), A_28_6 (y, z)) + A_33_6 (A_5_32 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_6 (x, z), A_32_6 (y, z)) + A_33_6 (A_5_33 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_6 (x, z), A_33_6 (y, z)) + A_33_7 (A_3_33 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_7 (x, z), A_33_7 (y, z)) + A_33_7 (A_5_6 (A_4_3 (S, x), y), z) -> A_10_36 (A_3_7 (x, z), A_6_7 (y, z)) + A_33_7 (A_5_7 (A_4_3 (S, x), y), z) -> A_10_36 (A_3_7 (x, z), A_7_7 (y, z)) + A_33_7 (A_5_8 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_7 (x, z), A_8_7 (y, z)) + A_33_7 (A_5_9 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_7 (x, z), A_9_7 (y, z)) + A_33_7 (A_5_10 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_7 (x, z), A_10_7 (y, z)) + A_33_7 (A_5_11 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_7 (x, z), A_11_7 (y, z)) + A_33_7 (A_5_12 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_7 (x, z), A_12_7 (y, z)) + A_33_7 (A_5_13 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_7 (x, z), A_13_7 (y, z)) + A_33_7 (A_5_14 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_7 (x, z), A_14_7 (y, z)) + A_33_7 (A_5_15 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_7 (x, z), A_15_7 (y, z)) + A_33_7 (A_5_16 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_7 (x, z), A_16_7 (y, z)) + A_33_7 (A_5_17 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_7 (x, z), A_17_7 (y, z)) + A_33_7 (A_5_18 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_7 (x, z), A_18_7 (y, z)) + A_33_7 (A_5_19 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_7 (x, z), A_19_7 (y, z)) + A_33_7 (A_5_22 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_7 (x, z), A_22_7 (y, z)) + A_33_7 (A_5_23 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_7 (x, z), A_23_7 (y, z)) + A_33_7 (A_5_24 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_7 (x, z), A_24_7 (y, z)) + A_33_7 (A_5_25 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_7 (x, z), A_25_7 (y, z)) + A_33_7 (A_5_26 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_7 (x, z), A_26_7 (y, z)) + A_33_7 (A_5_27 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_7 (x, z), A_27_7 (y, z)) + A_33_7 (A_5_28 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_7 (x, z), A_28_7 (y, z)) + A_33_7 (A_5_32 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_7 (x, z), A_32_7 (y, z)) + A_33_7 (A_5_33 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_7 (x, z), A_33_7 (y, z)) + A_33_8 (A_3_33 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_8 (x, z), A_33_8 (y, z)) + A_33_8 (A_5_6 (A_4_3 (S, x), y), z) -> A_8_36 (A_3_8 (x, z), A_6_8 (y, z)) + A_33_8 (A_5_7 (A_4_3 (S, x), y), z) -> A_8_36 (A_3_8 (x, z), A_7_8 (y, z)) + A_33_8 (A_5_8 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_8 (x, z), A_8_8 (y, z)) + A_33_8 (A_5_9 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_8 (x, z), A_9_8 (y, z)) + A_33_8 (A_5_10 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_8 (x, z), A_10_8 (y, z)) + A_33_8 (A_5_11 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_8 (x, z), A_11_8 (y, z)) + A_33_8 (A_5_12 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_8 (x, z), A_12_8 (y, z)) + A_33_8 (A_5_13 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_8 (x, z), A_13_8 (y, z)) + A_33_8 (A_5_14 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_8 (x, z), A_14_8 (y, z)) + A_33_8 (A_5_15 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_8 (x, z), A_15_8 (y, z)) + A_33_8 (A_5_16 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_8 (x, z), A_16_8 (y, z)) + A_33_8 (A_5_17 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_8 (x, z), A_17_8 (y, z)) + A_33_8 (A_5_18 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_8 (x, z), A_18_8 (y, z)) + A_33_8 (A_5_19 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_8 (x, z), A_19_8 (y, z)) + A_33_8 (A_5_22 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_8 (x, z), A_22_8 (y, z)) + A_33_8 (A_5_23 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_8 (x, z), A_23_8 (y, z)) + A_33_8 (A_5_24 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_8 (x, z), A_24_8 (y, z)) + A_33_8 (A_5_25 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_8 (x, z), A_25_8 (y, z)) + A_33_8 (A_5_26 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_8 (x, z), A_26_8 (y, z)) + A_33_8 (A_5_27 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_8 (x, z), A_27_8 (y, z)) + A_33_8 (A_5_28 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_8 (x, z), A_28_8 (y, z)) + A_33_8 (A_5_32 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_8 (x, z), A_32_8 (y, z)) + A_33_8 (A_5_33 (A_4_3 (S, x), y), z) -> A_8_37 (A_3_8 (x, z), A_33_8 (y, z)) + A_33_9 (A_3_33 (A_4_4 (S, x), y), z) -> A_13_37 (A_4_9 (x, z), A_33_9 (y, z)) + A_33_9 (A_5_6 (A_4_3 (S, x), y), z) -> A_9_36 (A_3_9 (x, z), A_6_9 (y, z)) + A_33_9 (A_5_7 (A_4_3 (S, x), y), z) -> A_9_36 (A_3_9 (x, z), A_7_9 (y, z)) + A_33_9 (A_5_8 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_9 (x, z), A_8_9 (y, z)) + A_33_9 (A_5_9 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_9 (x, z), A_9_9 (y, z)) + A_33_9 (A_5_10 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_9 (x, z), A_10_9 (y, z)) + A_33_9 (A_5_11 (A_4_3 (S, x), y), z) -> A_9_36 (A_3_9 (x, z), A_11_9 (y, z)) + A_33_9 (A_5_12 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_9 (x, z), A_12_9 (y, z)) + A_33_9 (A_5_13 (A_4_3 (S, x), y), z) -> A_9_36 (A_3_9 (x, z), A_13_9 (y, z)) + A_33_9 (A_5_14 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_9 (x, z), A_14_9 (y, z)) + A_33_9 (A_5_15 (A_4_3 (S, x), y), z) -> A_9_36 (A_3_9 (x, z), A_15_9 (y, z)) + A_33_9 (A_5_16 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_9 (x, z), A_16_9 (y, z)) + A_33_9 (A_5_17 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_9 (x, z), A_17_9 (y, z)) + A_33_9 (A_5_18 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_9 (x, z), A_18_9 (y, z)) + A_33_9 (A_5_19 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_9 (x, z), A_19_9 (y, z)) + A_33_9 (A_5_22 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_9 (x, z), A_22_9 (y, z)) + A_33_9 (A_5_23 (A_4_3 (S, x), y), z) -> A_9_36 (A_3_9 (x, z), A_23_9 (y, z)) + A_33_9 (A_5_24 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_9 (x, z), A_24_9 (y, z)) + A_33_9 (A_5_25 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_9 (x, z), A_25_9 (y, z)) + A_33_9 (A_5_26 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_9 (x, z), A_26_9 (y, z)) + A_33_9 (A_5_27 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_9 (x, z), A_27_9 (y, z)) + A_33_9 (A_5_28 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_9 (x, z), A_28_9 (y, z)) + A_33_9 (A_5_32 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_9 (x, z), A_32_9 (y, z)) + A_33_9 (A_5_33 (A_4_3 (S, x), y), z) -> A_9_37 (A_3_9 (x, z), A_33_9 (y, z)) + A_33_10 (A_3_33 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_10 (x, z), A_33_10 (y, z)) + A_33_10 (A_5_6 (A_4_3 (S, x), y), z) -> A_10_36 (A_3_10 (x, z), A_6_10 (y, z)) + A_33_10 (A_5_7 (A_4_3 (S, x), y), z) -> A_10_36 (A_3_10 (x, z), A_7_10 (y, z)) + A_33_10 (A_5_8 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_10 (x, z), A_8_10 (y, z)) + A_33_10 (A_5_9 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_10 (x, z), A_9_10 (y, z)) + A_33_10 (A_5_10 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_10 (x, z), A_10_10 (y, z)) + A_33_10 (A_5_11 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_10 (x, z), A_11_10 (y, z)) + A_33_10 (A_5_12 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_10 (x, z), A_12_10 (y, z)) + A_33_10 (A_5_13 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_10 (x, z), A_13_10 (y, z)) + A_33_10 (A_5_14 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_10 (x, z), A_14_10 (y, z)) + A_33_10 (A_5_15 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_10 (x, z), A_15_10 (y, z)) + A_33_10 (A_5_16 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_10 (x, z), A_16_10 (y, z)) + A_33_10 (A_5_17 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_10 (x, z), A_17_10 (y, z)) + A_33_10 (A_5_18 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_10 (x, z), A_18_10 (y, z)) + A_33_10 (A_5_19 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_10 (x, z), A_19_10 (y, z)) + A_33_10 (A_5_22 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_10 (x, z), A_22_10 (y, z)) + A_33_10 (A_5_23 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_10 (x, z), A_23_10 (y, z)) + A_33_10 (A_5_24 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_10 (x, z), A_24_10 (y, z)) + A_33_10 (A_5_25 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_10 (x, z), A_25_10 (y, z)) + A_33_10 (A_5_26 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_10 (x, z), A_26_10 (y, z)) + A_33_10 (A_5_27 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_10 (x, z), A_27_10 (y, z)) + A_33_10 (A_5_28 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_10 (x, z), A_28_10 (y, z)) + A_33_10 (A_5_32 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_10 (x, z), A_32_10 (y, z)) + A_33_10 (A_5_33 (A_4_3 (S, x), y), z) -> A_10_37 (A_3_10 (x, z), A_33_10 (y, z)) + A_33_11 (A_3_33 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_11 (x, z), A_33_11 (y, z)) + A_33_11 (A_5_6 (A_4_3 (S, x), y), z) -> A_12_36 (A_3_11 (x, z), A_6_11 (y, z)) + A_33_11 (A_5_7 (A_4_3 (S, x), y), z) -> A_12_36 (A_3_11 (x, z), A_7_11 (y, z)) + A_33_11 (A_5_8 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_11 (x, z), A_8_11 (y, z)) + A_33_11 (A_5_9 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_11 (x, z), A_9_11 (y, z)) + A_33_11 (A_5_10 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_11 (x, z), A_10_11 (y, z)) + A_33_11 (A_5_11 (A_4_3 (S, x), y), z) -> A_12_36 (A_3_11 (x, z), A_11_11 (y, z)) + A_33_11 (A_5_12 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_11 (x, z), A_12_11 (y, z)) + A_33_11 (A_5_13 (A_4_3 (S, x), y), z) -> A_12_36 (A_3_11 (x, z), A_13_11 (y, z)) + A_33_11 (A_5_14 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_11 (x, z), A_14_11 (y, z)) + A_33_11 (A_5_15 (A_4_3 (S, x), y), z) -> A_12_36 (A_3_11 (x, z), A_15_11 (y, z)) + A_33_11 (A_5_16 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_11 (x, z), A_16_11 (y, z)) + A_33_11 (A_5_17 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_11 (x, z), A_17_11 (y, z)) + A_33_11 (A_5_18 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_11 (x, z), A_18_11 (y, z)) + A_33_11 (A_5_19 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_11 (x, z), A_19_11 (y, z)) + A_33_11 (A_5_22 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_11 (x, z), A_22_11 (y, z)) + A_33_11 (A_5_23 (A_4_3 (S, x), y), z) -> A_12_36 (A_3_11 (x, z), A_23_11 (y, z)) + A_33_11 (A_5_24 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_11 (x, z), A_24_11 (y, z)) + A_33_11 (A_5_25 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_11 (x, z), A_25_11 (y, z)) + A_33_11 (A_5_26 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_11 (x, z), A_26_11 (y, z)) + A_33_11 (A_5_27 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_11 (x, z), A_27_11 (y, z)) + A_33_11 (A_5_28 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_11 (x, z), A_28_11 (y, z)) + A_33_11 (A_5_32 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_11 (x, z), A_32_11 (y, z)) + A_33_11 (A_5_33 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_11 (x, z), A_33_11 (y, z)) + A_33_12 (A_3_33 (A_4_4 (S, x), y), z) -> A_15_37 (A_4_12 (x, z), A_33_12 (y, z)) + A_33_12 (A_5_6 (A_4_3 (S, x), y), z) -> A_12_36 (A_3_12 (x, z), A_6_12 (y, z)) + A_33_12 (A_5_7 (A_4_3 (S, x), y), z) -> A_12_36 (A_3_12 (x, z), A_7_12 (y, z)) + A_33_12 (A_5_8 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_12 (x, z), A_8_12 (y, z)) + A_33_12 (A_5_9 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_12 (x, z), A_9_12 (y, z)) + A_33_12 (A_5_10 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_12 (x, z), A_10_12 (y, z)) + A_33_12 (A_5_11 (A_4_3 (S, x), y), z) -> A_12_36 (A_3_12 (x, z), A_11_12 (y, z)) + A_33_12 (A_5_12 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_12 (x, z), A_12_12 (y, z)) + A_33_12 (A_5_13 (A_4_3 (S, x), y), z) -> A_12_36 (A_3_12 (x, z), A_13_12 (y, z)) + A_33_12 (A_5_14 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_12 (x, z), A_14_12 (y, z)) + A_33_12 (A_5_15 (A_4_3 (S, x), y), z) -> A_12_36 (A_3_12 (x, z), A_15_12 (y, z)) + A_33_12 (A_5_16 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_12 (x, z), A_16_12 (y, z)) + A_33_12 (A_5_17 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_12 (x, z), A_17_12 (y, z)) + A_33_12 (A_5_18 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_12 (x, z), A_18_12 (y, z)) + A_33_12 (A_5_19 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_12 (x, z), A_19_12 (y, z)) + A_33_12 (A_5_22 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_12 (x, z), A_22_12 (y, z)) + A_33_12 (A_5_23 (A_4_3 (S, x), y), z) -> A_12_36 (A_3_12 (x, z), A_23_12 (y, z)) + A_33_12 (A_5_24 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_12 (x, z), A_24_12 (y, z)) + A_33_12 (A_5_25 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_12 (x, z), A_25_12 (y, z)) + A_33_12 (A_5_26 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_12 (x, z), A_26_12 (y, z)) + A_33_12 (A_5_27 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_12 (x, z), A_27_12 (y, z)) + A_33_12 (A_5_28 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_12 (x, z), A_28_12 (y, z)) + A_33_12 (A_5_32 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_12 (x, z), A_32_12 (y, z)) + A_33_12 (A_5_33 (A_4_3 (S, x), y), z) -> A_12_37 (A_3_12 (x, z), A_33_12 (y, z)) + A_33_13 (A_3_33 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_13 (x, z), A_33_13 (y, z)) + A_33_13 (A_5_6 (A_4_3 (S, x), y), z) -> A_14_36 (A_3_13 (x, z), A_6_13 (y, z)) + A_33_13 (A_5_7 (A_4_3 (S, x), y), z) -> A_14_36 (A_3_13 (x, z), A_7_13 (y, z)) + A_33_13 (A_5_8 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_13 (x, z), A_8_13 (y, z)) + A_33_13 (A_5_9 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_13 (x, z), A_9_13 (y, z)) + A_33_13 (A_5_10 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_13 (x, z), A_10_13 (y, z)) + A_33_13 (A_5_11 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_13 (x, z), A_11_13 (y, z)) + A_33_13 (A_5_12 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_13 (x, z), A_12_13 (y, z)) + A_33_13 (A_5_13 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_13 (x, z), A_13_13 (y, z)) + A_33_13 (A_5_14 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_13 (x, z), A_14_13 (y, z)) + A_33_13 (A_5_15 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_13 (x, z), A_15_13 (y, z)) + A_33_13 (A_5_16 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_13 (x, z), A_16_13 (y, z)) + A_33_13 (A_5_17 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_13 (x, z), A_17_13 (y, z)) + A_33_13 (A_5_18 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_13 (x, z), A_18_13 (y, z)) + A_33_13 (A_5_19 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_13 (x, z), A_19_13 (y, z)) + A_33_13 (A_5_22 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_13 (x, z), A_22_13 (y, z)) + A_33_13 (A_5_23 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_13 (x, z), A_23_13 (y, z)) + A_33_13 (A_5_24 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_13 (x, z), A_24_13 (y, z)) + A_33_13 (A_5_25 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_13 (x, z), A_25_13 (y, z)) + A_33_13 (A_5_26 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_13 (x, z), A_26_13 (y, z)) + A_33_13 (A_5_27 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_13 (x, z), A_27_13 (y, z)) + A_33_13 (A_5_28 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_13 (x, z), A_28_13 (y, z)) + A_33_13 (A_5_32 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_13 (x, z), A_32_13 (y, z)) + A_33_13 (A_5_33 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_13 (x, z), A_33_13 (y, z)) + A_33_14 (A_3_33 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_14 (x, z), A_33_14 (y, z)) + A_33_14 (A_5_6 (A_4_3 (S, x), y), z) -> A_14_36 (A_3_14 (x, z), A_6_14 (y, z)) + A_33_14 (A_5_7 (A_4_3 (S, x), y), z) -> A_14_36 (A_3_14 (x, z), A_7_14 (y, z)) + A_33_14 (A_5_8 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_14 (x, z), A_8_14 (y, z)) + A_33_14 (A_5_9 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_14 (x, z), A_9_14 (y, z)) + A_33_14 (A_5_10 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_14 (x, z), A_10_14 (y, z)) + A_33_14 (A_5_11 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_14 (x, z), A_11_14 (y, z)) + A_33_14 (A_5_12 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_14 (x, z), A_12_14 (y, z)) + A_33_14 (A_5_13 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_14 (x, z), A_13_14 (y, z)) + A_33_14 (A_5_14 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_14 (x, z), A_14_14 (y, z)) + A_33_14 (A_5_15 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_14 (x, z), A_15_14 (y, z)) + A_33_14 (A_5_16 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_14 (x, z), A_16_14 (y, z)) + A_33_14 (A_5_17 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_14 (x, z), A_17_14 (y, z)) + A_33_14 (A_5_18 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_14 (x, z), A_18_14 (y, z)) + A_33_14 (A_5_19 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_14 (x, z), A_19_14 (y, z)) + A_33_14 (A_5_22 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_14 (x, z), A_22_14 (y, z)) + A_33_14 (A_5_23 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_14 (x, z), A_23_14 (y, z)) + A_33_14 (A_5_24 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_14 (x, z), A_24_14 (y, z)) + A_33_14 (A_5_25 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_14 (x, z), A_25_14 (y, z)) + A_33_14 (A_5_26 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_14 (x, z), A_26_14 (y, z)) + A_33_14 (A_5_27 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_14 (x, z), A_27_14 (y, z)) + A_33_14 (A_5_28 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_14 (x, z), A_28_14 (y, z)) + A_33_14 (A_5_32 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_14 (x, z), A_32_14 (y, z)) + A_33_14 (A_5_33 (A_4_3 (S, x), y), z) -> A_14_37 (A_3_14 (x, z), A_33_14 (y, z)) + A_33_15 (A_3_33 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_15 (x, z), A_33_15 (y, z)) + A_33_15 (A_5_6 (A_4_3 (S, x), y), z) -> A_16_36 (A_3_15 (x, z), A_6_15 (y, z)) + A_33_15 (A_5_7 (A_4_3 (S, x), y), z) -> A_16_36 (A_3_15 (x, z), A_7_15 (y, z)) + A_33_15 (A_5_8 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_15 (x, z), A_8_15 (y, z)) + A_33_15 (A_5_9 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_15 (x, z), A_9_15 (y, z)) + A_33_15 (A_5_10 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_15 (x, z), A_10_15 (y, z)) + A_33_15 (A_5_11 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_15 (x, z), A_11_15 (y, z)) + A_33_15 (A_5_12 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_15 (x, z), A_12_15 (y, z)) + A_33_15 (A_5_13 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_15 (x, z), A_13_15 (y, z)) + A_33_15 (A_5_14 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_15 (x, z), A_14_15 (y, z)) + A_33_15 (A_5_15 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_15 (x, z), A_15_15 (y, z)) + A_33_15 (A_5_16 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_15 (x, z), A_16_15 (y, z)) + A_33_15 (A_5_17 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_15 (x, z), A_17_15 (y, z)) + A_33_15 (A_5_18 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_15 (x, z), A_18_15 (y, z)) + A_33_15 (A_5_19 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_15 (x, z), A_19_15 (y, z)) + A_33_15 (A_5_22 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_15 (x, z), A_22_15 (y, z)) + A_33_15 (A_5_23 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_15 (x, z), A_23_15 (y, z)) + A_33_15 (A_5_24 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_15 (x, z), A_24_15 (y, z)) + A_33_15 (A_5_25 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_15 (x, z), A_25_15 (y, z)) + A_33_15 (A_5_26 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_15 (x, z), A_26_15 (y, z)) + A_33_15 (A_5_27 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_15 (x, z), A_27_15 (y, z)) + A_33_15 (A_5_28 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_15 (x, z), A_28_15 (y, z)) + A_33_15 (A_5_32 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_15 (x, z), A_32_15 (y, z)) + A_33_15 (A_5_33 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_15 (x, z), A_33_15 (y, z)) + A_33_16 (A_3_33 (A_4_4 (S, x), y), z) -> A_18_37 (A_4_16 (x, z), A_33_16 (y, z)) + A_33_16 (A_5_6 (A_4_3 (S, x), y), z) -> A_16_36 (A_3_16 (x, z), A_6_16 (y, z)) + A_33_16 (A_5_7 (A_4_3 (S, x), y), z) -> A_16_36 (A_3_16 (x, z), A_7_16 (y, z)) + A_33_16 (A_5_8 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_16 (x, z), A_8_16 (y, z)) + A_33_16 (A_5_9 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_16 (x, z), A_9_16 (y, z)) + A_33_16 (A_5_10 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_16 (x, z), A_10_16 (y, z)) + A_33_16 (A_5_11 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_16 (x, z), A_11_16 (y, z)) + A_33_16 (A_5_12 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_16 (x, z), A_12_16 (y, z)) + A_33_16 (A_5_13 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_16 (x, z), A_13_16 (y, z)) + A_33_16 (A_5_14 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_16 (x, z), A_14_16 (y, z)) + A_33_16 (A_5_15 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_16 (x, z), A_15_16 (y, z)) + A_33_16 (A_5_16 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_16 (x, z), A_16_16 (y, z)) + A_33_16 (A_5_17 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_16 (x, z), A_17_16 (y, z)) + A_33_16 (A_5_18 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_16 (x, z), A_18_16 (y, z)) + A_33_16 (A_5_19 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_16 (x, z), A_19_16 (y, z)) + A_33_16 (A_5_22 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_16 (x, z), A_22_16 (y, z)) + A_33_16 (A_5_23 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_16 (x, z), A_23_16 (y, z)) + A_33_16 (A_5_24 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_16 (x, z), A_24_16 (y, z)) + A_33_16 (A_5_25 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_16 (x, z), A_25_16 (y, z)) + A_33_16 (A_5_26 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_16 (x, z), A_26_16 (y, z)) + A_33_16 (A_5_27 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_16 (x, z), A_27_16 (y, z)) + A_33_16 (A_5_28 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_16 (x, z), A_28_16 (y, z)) + A_33_16 (A_5_32 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_16 (x, z), A_32_16 (y, z)) + A_33_16 (A_5_33 (A_4_3 (S, x), y), z) -> A_16_37 (A_3_16 (x, z), A_33_16 (y, z)) + A_33_18 (A_3_33 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_18 (x, z), A_33_18 (y, z)) + A_33_18 (A_5_6 (A_4_3 (S, x), y), z) -> A_18_36 (A_3_18 (x, z), A_6_18 (y, z)) + A_33_18 (A_5_7 (A_4_3 (S, x), y), z) -> A_18_36 (A_3_18 (x, z), A_7_18 (y, z)) + A_33_18 (A_5_8 (A_4_3 (S, x), y), z) -> A_18_37 (A_3_18 (x, z), A_8_18 (y, z)) + A_33_18 (A_5_9 (A_4_3 (S, x), y), z) -> A_18_37 (A_3_18 (x, z), A_9_18 (y, z)) + A_33_18 (A_5_10 (A_4_3 (S, x), y), z) -> A_18_37 (A_3_18 (x, z), A_10_18 (y, z)) + A_33_18 (A_5_11 (A_4_3 (S, x), y), z) -> A_18_37 (A_3_18 (x, z), A_11_18 (y, z)) + A_33_18 (A_5_12 (A_4_3 (S, x), y), z) -> A_18_37 (A_3_18 (x, z), A_12_18 (y, z)) + A_33_18 (A_5_13 (A_4_3 (S, x), y), z) -> A_18_37 (A_3_18 (x, z), A_13_18 (y, z)) + A_33_18 (A_5_14 (A_4_3 (S, x), y), z) -> A_18_37 (A_3_18 (x, z), A_14_18 (y, z)) + A_33_18 (A_5_15 (A_4_3 (S, x), y), z) -> A_18_37 (A_3_18 (x, z), A_15_18 (y, z)) + A_33_18 (A_5_16 (A_4_3 (S, x), y), z) -> A_18_37 (A_3_18 (x, z), A_16_18 (y, z)) + A_33_18 (A_5_17 (A_4_3 (S, x), y), z) -> A_18_37 (A_3_18 (x, z), A_17_18 (y, z)) + A_33_18 (A_5_18 (A_4_3 (S, x), y), z) -> A_18_37 (A_3_18 (x, z), A_18_18 (y, z)) + A_33_18 (A_5_19 (A_4_3 (S, x), y), z) -> A_18_37 (A_3_18 (x, z), A_19_18 (y, z)) + A_33_18 (A_5_22 (A_4_3 (S, x), y), z) -> A_18_37 (A_3_18 (x, z), A_22_18 (y, z)) + A_33_18 (A_5_23 (A_4_3 (S, x), y), z) -> A_18_37 (A_3_18 (x, z), A_23_18 (y, z)) + A_33_18 (A_5_24 (A_4_3 (S, x), y), z) -> A_18_37 (A_3_18 (x, z), A_24_18 (y, z)) + A_33_18 (A_5_25 (A_4_3 (S, x), y), z) -> A_18_37 (A_3_18 (x, z), A_25_18 (y, z)) + A_33_18 (A_5_26 (A_4_3 (S, x), y), z) -> A_18_37 (A_3_18 (x, z), A_26_18 (y, z)) + A_33_18 (A_5_27 (A_4_3 (S, x), y), z) -> A_18_37 (A_3_18 (x, z), A_27_18 (y, z)) + A_33_18 (A_5_28 (A_4_3 (S, x), y), z) -> A_18_37 (A_3_18 (x, z), A_28_18 (y, z)) + A_33_18 (A_5_32 (A_4_3 (S, x), y), z) -> A_18_37 (A_3_18 (x, z), A_32_18 (y, z)) + A_33_18 (A_5_33 (A_4_3 (S, x), y), z) -> A_18_37 (A_3_18 (x, z), A_33_18 (y, z)) + A_33_23 (A_3_33 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_23 (x, z), A_33_23 (y, z)) + A_33_23 (A_5_6 (A_4_3 (S, x), y), z) -> A_26_36 (A_3_23 (x, z), A_6_23 (y, z)) + A_33_23 (A_5_7 (A_4_3 (S, x), y), z) -> A_26_36 (A_3_23 (x, z), A_7_23 (y, z)) + A_33_23 (A_5_8 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_23 (x, z), A_8_23 (y, z)) + A_33_23 (A_5_9 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_23 (x, z), A_9_23 (y, z)) + A_33_23 (A_5_10 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_23 (x, z), A_10_23 (y, z)) + A_33_23 (A_5_11 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_23 (x, z), A_11_23 (y, z)) + A_33_23 (A_5_12 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_23 (x, z), A_12_23 (y, z)) + A_33_23 (A_5_13 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_23 (x, z), A_13_23 (y, z)) + A_33_23 (A_5_14 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_23 (x, z), A_14_23 (y, z)) + A_33_23 (A_5_15 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_23 (x, z), A_15_23 (y, z)) + A_33_23 (A_5_16 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_23 (x, z), A_16_23 (y, z)) + A_33_23 (A_5_17 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_23 (x, z), A_17_23 (y, z)) + A_33_23 (A_5_18 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_23 (x, z), A_18_23 (y, z)) + A_33_23 (A_5_19 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_23 (x, z), A_19_23 (y, z)) + A_33_23 (A_5_22 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_23 (x, z), A_22_23 (y, z)) + A_33_23 (A_5_23 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_23 (x, z), A_23_23 (y, z)) + A_33_23 (A_5_24 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_23 (x, z), A_24_23 (y, z)) + A_33_23 (A_5_25 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_23 (x, z), A_25_23 (y, z)) + A_33_23 (A_5_26 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_23 (x, z), A_26_23 (y, z)) + A_33_23 (A_5_27 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_23 (x, z), A_27_23 (y, z)) + A_33_23 (A_5_28 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_23 (x, z), A_28_23 (y, z)) + A_33_23 (A_5_32 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_23 (x, z), A_32_23 (y, z)) + A_33_23 (A_5_33 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_23 (x, z), A_33_23 (y, z)) + A_33_26 (A_3_33 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_26 (x, z), A_33_26 (y, z)) + A_33_26 (A_5_6 (A_4_3 (S, x), y), z) -> A_26_36 (A_3_26 (x, z), A_6_26 (y, z)) + A_33_26 (A_5_7 (A_4_3 (S, x), y), z) -> A_26_36 (A_3_26 (x, z), A_7_26 (y, z)) + A_33_26 (A_5_8 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_26 (x, z), A_8_26 (y, z)) + A_33_26 (A_5_9 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_26 (x, z), A_9_26 (y, z)) + A_33_26 (A_5_10 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_26 (x, z), A_10_26 (y, z)) + A_33_26 (A_5_11 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_26 (x, z), A_11_26 (y, z)) + A_33_26 (A_5_12 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_26 (x, z), A_12_26 (y, z)) + A_33_26 (A_5_13 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_26 (x, z), A_13_26 (y, z)) + A_33_26 (A_5_14 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_26 (x, z), A_14_26 (y, z)) + A_33_26 (A_5_15 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_26 (x, z), A_15_26 (y, z)) + A_33_26 (A_5_16 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_26 (x, z), A_16_26 (y, z)) + A_33_26 (A_5_17 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_26 (x, z), A_17_26 (y, z)) + A_33_26 (A_5_18 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_26 (x, z), A_18_26 (y, z)) + A_33_26 (A_5_19 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_26 (x, z), A_19_26 (y, z)) + A_33_26 (A_5_22 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_26 (x, z), A_22_26 (y, z)) + A_33_26 (A_5_23 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_26 (x, z), A_23_26 (y, z)) + A_33_26 (A_5_24 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_26 (x, z), A_24_26 (y, z)) + A_33_26 (A_5_25 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_26 (x, z), A_25_26 (y, z)) + A_33_26 (A_5_26 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_26 (x, z), A_26_26 (y, z)) + A_33_26 (A_5_27 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_26 (x, z), A_27_26 (y, z)) + A_33_26 (A_5_28 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_26 (x, z), A_28_26 (y, z)) + A_33_26 (A_5_32 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_26 (x, z), A_32_26 (y, z)) + A_33_26 (A_5_33 (A_4_3 (S, x), y), z) -> A_26_37 (A_3_26 (x, z), A_33_26 (y, z)) + A_33_28 (A_3_33 (A_4_4 (S, x), y), z) -> A_28_37 (A_4_28 (x, z), A_33_28 (y, z)) + A_33_28 (A_5_6 (A_4_3 (S, x), y), z) -> A_28_36 (A_3_28 (x, z), A_6_28 (y, z)) + A_33_28 (A_5_7 (A_4_3 (S, x), y), z) -> A_28_36 (A_3_28 (x, z), A_7_28 (y, z)) + A_33_28 (A_5_8 (A_4_3 (S, x), y), z) -> A_28_37 (A_3_28 (x, z), A_8_28 (y, z)) + A_33_28 (A_5_9 (A_4_3 (S, x), y), z) -> A_28_37 (A_3_28 (x, z), A_9_28 (y, z)) + A_33_28 (A_5_10 (A_4_3 (S, x), y), z) -> A_28_37 (A_3_28 (x, z), A_10_28 (y, z)) + A_33_28 (A_5_11 (A_4_3 (S, x), y), z) -> A_28_37 (A_3_28 (x, z), A_11_28 (y, z)) + A_33_28 (A_5_12 (A_4_3 (S, x), y), z) -> A_28_37 (A_3_28 (x, z), A_12_28 (y, z)) + A_33_28 (A_5_13 (A_4_3 (S, x), y), z) -> A_28_37 (A_3_28 (x, z), A_13_28 (y, z)) + A_33_28 (A_5_14 (A_4_3 (S, x), y), z) -> A_28_37 (A_3_28 (x, z), A_14_28 (y, z)) + A_33_28 (A_5_15 (A_4_3 (S, x), y), z) -> A_28_37 (A_3_28 (x, z), A_15_28 (y, z)) + A_33_28 (A_5_16 (A_4_3 (S, x), y), z) -> A_28_37 (A_3_28 (x, z), A_16_28 (y, z)) + A_33_28 (A_5_17 (A_4_3 (S, x), y), z) -> A_28_37 (A_3_28 (x, z), A_17_28 (y, z)) + A_33_28 (A_5_18 (A_4_3 (S, x), y), z) -> A_28_37 (A_3_28 (x, z), A_18_28 (y, z)) + A_33_28 (A_5_19 (A_4_3 (S, x), y), z) -> A_28_37 (A_3_28 (x, z), A_19_28 (y, z)) + A_33_28 (A_5_22 (A_4_3 (S, x), y), z) -> A_28_37 (A_3_28 (x, z), A_22_28 (y, z)) + A_33_28 (A_5_23 (A_4_3 (S, x), y), z) -> A_28_37 (A_3_28 (x, z), A_23_28 (y, z)) + A_33_28 (A_5_24 (A_4_3 (S, x), y), z) -> A_28_37 (A_3_28 (x, z), A_24_28 (y, z)) + A_33_28 (A_5_25 (A_4_3 (S, x), y), z) -> A_28_37 (A_3_28 (x, z), A_25_28 (y, z)) + A_33_28 (A_5_26 (A_4_3 (S, x), y), z) -> A_28_37 (A_3_28 (x, z), A_26_28 (y, z)) + A_33_28 (A_5_27 (A_4_3 (S, x), y), z) -> A_28_37 (A_3_28 (x, z), A_27_28 (y, z)) + A_33_28 (A_5_28 (A_4_3 (S, x), y), z) -> A_28_37 (A_3_28 (x, z), A_28_28 (y, z)) + A_33_28 (A_5_32 (A_4_3 (S, x), y), z) -> A_28_37 (A_3_28 (x, z), A_32_28 (y, z)) + A_33_28 (A_5_33 (A_4_3 (S, x), y), z) -> A_28_37 (A_3_28 (x, z), A_33_28 (y, z)) + A_36_4 (A_3_36 (A_4_4 (S, x), y), z) -> A_3_37 (A_4_4 (x, z), A_36_4 (y, z)) + A_36_4 (A_5_34 (A_4_3 (S, x), y), z) -> A_0_35 (A_3_4 (x, z), A_34_4 (y, z)) + A_36_4 (A_5_35 (A_4_3 (S, x), y), z) -> A_0_36 (A_3_4 (x, z), A_35_4 (y, z)) + A_36_4 (A_5_36 (A_4_3 (S, x), y), z) -> A_0_37 (A_3_4 (x, z), A_36_4 (y, z)) + A_36_4 (A_6_5 (A_4_0 (S, x), y), z) -> A_1_19 (A_0_4 (x, z), A_5_4 (y, z)) + A_36_4 (A_6_6 (A_4_0 (S, x), y), z) -> A_1_20 (A_0_4 (x, z), A_6_4 (y, z)) + A_36_4 (A_6_7 (A_4_0 (S, x), y), z) -> A_1_21 (A_0_4 (x, z), A_7_4 (y, z)) + A_36_4 (A_6_8 (A_4_0 (S, x), y), z) -> A_1_20 (A_0_4 (x, z), A_8_4 (y, z)) + A_36_4 (A_6_9 (A_4_0 (S, x), y), z) -> A_1_19 (A_0_4 (x, z), A_9_4 (y, z)) + A_36_4 (A_6_10 (A_4_0 (S, x), y), z) -> A_1_21 (A_0_4 (x, z), A_10_4 (y, z)) + A_36_4 (A_6_11 (A_4_0 (S, x), y), z) -> A_1_25 (A_0_4 (x, z), A_11_4 (y, z)) + A_36_4 (A_6_12 (A_4_0 (S, x), y), z) -> A_1_25 (A_0_4 (x, z), A_12_4 (y, z)) + A_36_4 (A_6_13 (A_4_0 (S, x), y), z) -> A_1_30 (A_0_4 (x, z), A_13_4 (y, z)) + A_36_4 (A_6_14 (A_4_0 (S, x), y), z) -> A_1_30 (A_0_4 (x, z), A_14_4 (y, z)) + A_36_4 (A_6_15 (A_4_0 (S, x), y), z) -> A_1_31 (A_0_4 (x, z), A_15_4 (y, z)) + A_36_4 (A_6_16 (A_4_0 (S, x), y), z) -> A_1_31 (A_0_4 (x, z), A_16_4 (y, z)) + A_36_4 (A_6_17 (A_4_0 (S, x), y), z) -> A_1_36 (A_0_4 (x, z), A_17_4 (y, z)) + A_36_4 (A_6_18 (A_4_0 (S, x), y), z) -> A_1_36 (A_0_4 (x, z), A_18_4 (y, z)) + A_36_4 (A_6_19 (A_4_0 (S, x), y), z) -> A_1_27 (A_0_4 (x, z), A_19_4 (y, z)) + A_36_4 (A_6_20 (A_4_0 (S, x), y), z) -> A_1_32 (A_0_4 (x, z), A_20_4 (y, z)) + A_36_4 (A_6_21 (A_4_0 (S, x), y), z) -> A_1_33 (A_0_4 (x, z), A_21_4 (y, z)) + A_36_4 (A_6_22 (A_4_0 (S, x), y), z) -> A_1_37 (A_0_4 (x, z), A_22_4 (y, z)) + A_36_4 (A_6_23 (A_4_0 (S, x), y), z) -> A_1_36 (A_0_4 (x, z), A_23_4 (y, z)) + A_36_4 (A_6_24 (A_4_0 (S, x), y), z) -> A_1_36 (A_0_4 (x, z), A_24_4 (y, z)) + A_36_4 (A_6_25 (A_4_0 (S, x), y), z) -> A_1_36 (A_0_4 (x, z), A_25_4 (y, z)) + A_36_4 (A_6_26 (A_4_0 (S, x), y), z) -> A_1_36 (A_0_4 (x, z), A_26_4 (y, z)) + A_36_4 (A_6_27 (A_4_0 (S, x), y), z) -> A_1_37 (A_0_4 (x, z), A_27_4 (y, z)) + A_36_4 (A_6_28 (A_4_0 (S, x), y), z) -> A_1_37 (A_0_4 (x, z), A_28_4 (y, z)) + A_36_4 (A_6_29 (A_4_0 (S, x), y), z) -> A_1_34 (A_0_4 (x, z), A_29_4 (y, z)) + A_36_4 (A_6_30 (A_4_0 (S, x), y), z) -> A_1_36 (A_0_4 (x, z), A_30_4 (y, z)) + A_36_4 (A_6_31 (A_4_0 (S, x), y), z) -> A_1_37 (A_0_4 (x, z), A_31_4 (y, z)) + A_36_4 (A_6_32 (A_4_0 (S, x), y), z) -> A_1_36 (A_0_4 (x, z), A_32_4 (y, z)) + A_36_4 (A_6_33 (A_4_0 (S, x), y), z) -> A_1_37 (A_0_4 (x, z), A_33_4 (y, z)) + A_36_4 (A_6_34 (A_4_0 (S, x), y), z) -> A_1_35 (A_0_4 (x, z), A_34_4 (y, z)) + A_36_4 (A_6_35 (A_4_0 (S, x), y), z) -> A_1_36 (A_0_4 (x, z), A_35_4 (y, z)) + A_36_4 (A_6_36 (A_4_0 (S, x), y), z) -> A_1_37 (A_0_4 (x, z), A_36_4 (y, z)) + A_36_4 (A_7_5 (A_4_1 (S, x), y), z) -> A_2_19 (A_1_4 (x, z), A_5_4 (y, z)) + A_36_4 (A_7_5 (A_4_2 (S, x), y), z) -> A_2_19 (A_2_4 (x, z), A_5_4 (y, z)) + A_36_4 (A_7_6 (A_4_1 (S, x), y), z) -> A_2_20 (A_1_4 (x, z), A_6_4 (y, z)) + A_36_4 (A_7_6 (A_4_2 (S, x), y), z) -> A_2_20 (A_2_4 (x, z), A_6_4 (y, z)) + A_36_4 (A_7_7 (A_4_1 (S, x), y), z) -> A_2_21 (A_1_4 (x, z), A_7_4 (y, z)) + A_36_4 (A_7_7 (A_4_2 (S, x), y), z) -> A_2_21 (A_2_4 (x, z), A_7_4 (y, z)) + A_36_4 (A_7_8 (A_4_1 (S, x), y), z) -> A_2_20 (A_1_4 (x, z), A_8_4 (y, z)) + A_36_4 (A_7_8 (A_4_2 (S, x), y), z) -> A_2_20 (A_2_4 (x, z), A_8_4 (y, z)) + A_36_4 (A_7_9 (A_4_1 (S, x), y), z) -> A_2_19 (A_1_4 (x, z), A_9_4 (y, z)) + A_36_4 (A_7_9 (A_4_2 (S, x), y), z) -> A_2_19 (A_2_4 (x, z), A_9_4 (y, z)) + A_36_4 (A_7_10 (A_4_1 (S, x), y), z) -> A_2_21 (A_1_4 (x, z), A_10_4 (y, z)) + A_36_4 (A_7_10 (A_4_2 (S, x), y), z) -> A_2_21 (A_2_4 (x, z), A_10_4 (y, z)) + A_36_4 (A_7_11 (A_4_1 (S, x), y), z) -> A_2_25 (A_1_4 (x, z), A_11_4 (y, z)) + A_36_4 (A_7_11 (A_4_2 (S, x), y), z) -> A_2_25 (A_2_4 (x, z), A_11_4 (y, z)) + A_36_4 (A_7_12 (A_4_1 (S, x), y), z) -> A_2_25 (A_1_4 (x, z), A_12_4 (y, z)) + A_36_4 (A_7_12 (A_4_2 (S, x), y), z) -> A_2_25 (A_2_4 (x, z), A_12_4 (y, z)) + A_36_4 (A_7_13 (A_4_1 (S, x), y), z) -> A_2_30 (A_1_4 (x, z), A_13_4 (y, z)) + A_36_4 (A_7_13 (A_4_2 (S, x), y), z) -> A_2_30 (A_2_4 (x, z), A_13_4 (y, z)) + A_36_4 (A_7_14 (A_4_1 (S, x), y), z) -> A_2_30 (A_1_4 (x, z), A_14_4 (y, z)) + A_36_4 (A_7_14 (A_4_2 (S, x), y), z) -> A_2_30 (A_2_4 (x, z), A_14_4 (y, z)) + A_36_4 (A_7_15 (A_4_1 (S, x), y), z) -> A_2_31 (A_1_4 (x, z), A_15_4 (y, z)) + A_36_4 (A_7_15 (A_4_2 (S, x), y), z) -> A_2_31 (A_2_4 (x, z), A_15_4 (y, z)) + A_36_4 (A_7_16 (A_4_1 (S, x), y), z) -> A_2_31 (A_1_4 (x, z), A_16_4 (y, z)) + A_36_4 (A_7_16 (A_4_2 (S, x), y), z) -> A_2_31 (A_2_4 (x, z), A_16_4 (y, z)) + A_36_4 (A_7_17 (A_4_1 (S, x), y), z) -> A_2_36 (A_1_4 (x, z), A_17_4 (y, z)) + A_36_4 (A_7_17 (A_4_2 (S, x), y), z) -> A_2_36 (A_2_4 (x, z), A_17_4 (y, z)) + A_36_4 (A_7_18 (A_4_1 (S, x), y), z) -> A_2_36 (A_1_4 (x, z), A_18_4 (y, z)) + A_36_4 (A_7_18 (A_4_2 (S, x), y), z) -> A_2_36 (A_2_4 (x, z), A_18_4 (y, z)) + A_36_4 (A_7_19 (A_4_1 (S, x), y), z) -> A_2_27 (A_1_4 (x, z), A_19_4 (y, z)) + A_36_4 (A_7_19 (A_4_2 (S, x), y), z) -> A_2_27 (A_2_4 (x, z), A_19_4 (y, z)) + A_36_4 (A_7_20 (A_4_1 (S, x), y), z) -> A_2_32 (A_1_4 (x, z), A_20_4 (y, z)) + A_36_4 (A_7_20 (A_4_2 (S, x), y), z) -> A_2_32 (A_2_4 (x, z), A_20_4 (y, z)) + A_36_4 (A_7_21 (A_4_1 (S, x), y), z) -> A_2_33 (A_1_4 (x, z), A_21_4 (y, z)) + A_36_4 (A_7_21 (A_4_2 (S, x), y), z) -> A_2_33 (A_2_4 (x, z), A_21_4 (y, z)) + A_36_4 (A_7_22 (A_4_1 (S, x), y), z) -> A_2_37 (A_1_4 (x, z), A_22_4 (y, z)) + A_36_4 (A_7_22 (A_4_2 (S, x), y), z) -> A_2_37 (A_2_4 (x, z), A_22_4 (y, z)) + A_36_4 (A_7_23 (A_4_1 (S, x), y), z) -> A_2_36 (A_1_4 (x, z), A_23_4 (y, z)) + A_36_4 (A_7_23 (A_4_2 (S, x), y), z) -> A_2_36 (A_2_4 (x, z), A_23_4 (y, z)) + A_36_4 (A_7_24 (A_4_1 (S, x), y), z) -> A_2_36 (A_1_4 (x, z), A_24_4 (y, z)) + A_36_4 (A_7_24 (A_4_2 (S, x), y), z) -> A_2_36 (A_2_4 (x, z), A_24_4 (y, z)) + A_36_4 (A_7_25 (A_4_1 (S, x), y), z) -> A_2_36 (A_1_4 (x, z), A_25_4 (y, z)) + A_36_4 (A_7_25 (A_4_2 (S, x), y), z) -> A_2_36 (A_2_4 (x, z), A_25_4 (y, z)) + A_36_4 (A_7_26 (A_4_1 (S, x), y), z) -> A_2_36 (A_1_4 (x, z), A_26_4 (y, z)) + A_36_4 (A_7_26 (A_4_2 (S, x), y), z) -> A_2_36 (A_2_4 (x, z), A_26_4 (y, z)) + A_36_4 (A_7_27 (A_4_1 (S, x), y), z) -> A_2_37 (A_1_4 (x, z), A_27_4 (y, z)) + A_36_4 (A_7_27 (A_4_2 (S, x), y), z) -> A_2_37 (A_2_4 (x, z), A_27_4 (y, z)) + A_36_4 (A_7_28 (A_4_1 (S, x), y), z) -> A_2_37 (A_1_4 (x, z), A_28_4 (y, z)) + A_36_4 (A_7_28 (A_4_2 (S, x), y), z) -> A_2_37 (A_2_4 (x, z), A_28_4 (y, z)) + A_36_4 (A_7_29 (A_4_1 (S, x), y), z) -> A_2_34 (A_1_4 (x, z), A_29_4 (y, z)) + A_36_4 (A_7_29 (A_4_2 (S, x), y), z) -> A_2_34 (A_2_4 (x, z), A_29_4 (y, z)) + A_36_4 (A_7_30 (A_4_1 (S, x), y), z) -> A_2_36 (A_1_4 (x, z), A_30_4 (y, z)) + A_36_4 (A_7_30 (A_4_2 (S, x), y), z) -> A_2_36 (A_2_4 (x, z), A_30_4 (y, z)) + A_36_4 (A_7_31 (A_4_1 (S, x), y), z) -> A_2_37 (A_1_4 (x, z), A_31_4 (y, z)) + A_36_4 (A_7_31 (A_4_2 (S, x), y), z) -> A_2_37 (A_2_4 (x, z), A_31_4 (y, z)) + A_36_4 (A_7_32 (A_4_1 (S, x), y), z) -> A_2_36 (A_1_4 (x, z), A_32_4 (y, z)) + A_36_4 (A_7_32 (A_4_2 (S, x), y), z) -> A_2_36 (A_2_4 (x, z), A_32_4 (y, z)) + A_36_4 (A_7_33 (A_4_1 (S, x), y), z) -> A_2_37 (A_1_4 (x, z), A_33_4 (y, z)) + A_36_4 (A_7_33 (A_4_2 (S, x), y), z) -> A_2_37 (A_2_4 (x, z), A_33_4 (y, z)) + A_36_4 (A_7_34 (A_4_1 (S, x), y), z) -> A_2_35 (A_1_4 (x, z), A_34_4 (y, z)) + A_36_4 (A_7_34 (A_4_2 (S, x), y), z) -> A_2_35 (A_2_4 (x, z), A_34_4 (y, z)) + A_36_4 (A_7_35 (A_4_1 (S, x), y), z) -> A_2_36 (A_1_4 (x, z), A_35_4 (y, z)) + A_36_4 (A_7_35 (A_4_2 (S, x), y), z) -> A_2_36 (A_2_4 (x, z), A_35_4 (y, z)) + A_36_4 (A_7_36 (A_4_1 (S, x), y), z) -> A_2_37 (A_1_4 (x, z), A_36_4 (y, z)) + A_36_4 (A_7_36 (A_4_2 (S, x), y), z) -> A_2_37 (A_2_4 (x, z), A_36_4 (y, z)) + A_36_4 (A_11_0 (A_4_5 (S, x), y), z) -> A_19_1 (A_5_4 (x, z), A_0_4 (y, z)) + A_36_4 (A_11_1 (A_4_5 (S, x), y), z) -> A_19_2 (A_5_4 (x, z), A_1_4 (y, z)) + A_36_4 (A_11_2 (A_4_5 (S, x), y), z) -> A_19_2 (A_5_4 (x, z), A_2_4 (y, z)) + A_36_4 (A_11_5 (A_4_5 (S, x), y), z) -> A_19_19 (A_5_4 (x, z), A_5_4 (y, z)) + A_36_4 (A_11_9 (A_4_5 (S, x), y), z) -> A_19_19 (A_5_4 (x, z), A_9_4 (y, z)) + A_36_4 (A_11_11 (A_4_5 (S, x), y), z) -> A_19_25 (A_5_4 (x, z), A_11_4 (y, z)) + A_36_4 (A_11_12 (A_4_5 (S, x), y), z) -> A_19_25 (A_5_4 (x, z), A_12_4 (y, z)) + A_36_4 (A_11_19 (A_4_5 (S, x), y), z) -> A_19_27 (A_5_4 (x, z), A_19_4 (y, z)) + A_36_4 (A_11_20 (A_4_5 (S, x), y), z) -> A_19_32 (A_5_4 (x, z), A_20_4 (y, z)) + A_36_4 (A_11_21 (A_4_5 (S, x), y), z) -> A_19_33 (A_5_4 (x, z), A_21_4 (y, z)) + A_36_4 (A_13_0 (A_4_9 (S, x), y), z) -> A_19_1 (A_9_4 (x, z), A_0_4 (y, z)) + A_36_4 (A_13_1 (A_4_9 (S, x), y), z) -> A_19_2 (A_9_4 (x, z), A_1_4 (y, z)) + A_36_4 (A_13_2 (A_4_9 (S, x), y), z) -> A_19_2 (A_9_4 (x, z), A_2_4 (y, z)) + A_36_4 (A_13_5 (A_4_9 (S, x), y), z) -> A_19_19 (A_9_4 (x, z), A_5_4 (y, z)) + A_36_4 (A_13_9 (A_4_9 (S, x), y), z) -> A_19_19 (A_9_4 (x, z), A_9_4 (y, z)) + A_36_4 (A_13_11 (A_4_9 (S, x), y), z) -> A_19_25 (A_9_4 (x, z), A_11_4 (y, z)) + A_36_4 (A_13_12 (A_4_9 (S, x), y), z) -> A_19_25 (A_9_4 (x, z), A_12_4 (y, z)) + A_36_4 (A_13_19 (A_4_9 (S, x), y), z) -> A_19_27 (A_9_4 (x, z), A_19_4 (y, z)) + A_36_4 (A_13_20 (A_4_9 (S, x), y), z) -> A_19_32 (A_9_4 (x, z), A_20_4 (y, z)) + A_36_4 (A_13_21 (A_4_9 (S, x), y), z) -> A_19_33 (A_9_4 (x, z), A_21_4 (y, z)) + A_36_4 (A_15_0 (A_4_11 (S, x), y), z) -> A_25_1 (A_11_4 (x, z), A_0_4 (y, z)) + A_36_4 (A_15_0 (A_4_12 (S, x), y), z) -> A_25_1 (A_12_4 (x, z), A_0_4 (y, z)) + A_36_4 (A_15_1 (A_4_11 (S, x), y), z) -> A_25_2 (A_11_4 (x, z), A_1_4 (y, z)) + A_36_4 (A_15_1 (A_4_12 (S, x), y), z) -> A_25_2 (A_12_4 (x, z), A_1_4 (y, z)) + A_36_4 (A_15_2 (A_4_11 (S, x), y), z) -> A_25_2 (A_11_4 (x, z), A_2_4 (y, z)) + A_36_4 (A_15_2 (A_4_12 (S, x), y), z) -> A_25_2 (A_12_4 (x, z), A_2_4 (y, z)) + A_36_4 (A_15_5 (A_4_11 (S, x), y), z) -> A_25_19 (A_11_4 (x, z), A_5_4 (y, z)) + A_36_4 (A_15_5 (A_4_12 (S, x), y), z) -> A_25_19 (A_12_4 (x, z), A_5_4 (y, z)) + A_36_4 (A_15_9 (A_4_11 (S, x), y), z) -> A_25_19 (A_11_4 (x, z), A_9_4 (y, z)) + A_36_4 (A_15_9 (A_4_12 (S, x), y), z) -> A_25_19 (A_12_4 (x, z), A_9_4 (y, z)) + A_36_4 (A_15_11 (A_4_11 (S, x), y), z) -> A_25_25 (A_11_4 (x, z), A_11_4 (y, z)) + A_36_4 (A_15_11 (A_4_12 (S, x), y), z) -> A_25_25 (A_12_4 (x, z), A_11_4 (y, z)) + A_36_4 (A_15_12 (A_4_11 (S, x), y), z) -> A_25_25 (A_11_4 (x, z), A_12_4 (y, z)) + A_36_4 (A_15_12 (A_4_12 (S, x), y), z) -> A_25_25 (A_12_4 (x, z), A_12_4 (y, z)) + A_36_4 (A_15_19 (A_4_11 (S, x), y), z) -> A_25_27 (A_11_4 (x, z), A_19_4 (y, z)) + A_36_4 (A_15_19 (A_4_12 (S, x), y), z) -> A_25_27 (A_12_4 (x, z), A_19_4 (y, z)) + A_36_4 (A_15_20 (A_4_11 (S, x), y), z) -> A_25_32 (A_11_4 (x, z), A_20_4 (y, z)) + A_36_4 (A_15_20 (A_4_12 (S, x), y), z) -> A_25_32 (A_12_4 (x, z), A_20_4 (y, z)) + A_36_4 (A_15_21 (A_4_11 (S, x), y), z) -> A_25_33 (A_11_4 (x, z), A_21_4 (y, z)) + A_36_4 (A_15_21 (A_4_12 (S, x), y), z) -> A_25_33 (A_12_4 (x, z), A_21_4 (y, z)) + A_36_4 (A_18_4 (A_4_6 (S, x), y), z) -> A_20_3 (A_6_4 (x, z), A_4_4 (y, z)) + A_36_4 (A_18_4 (A_4_7 (S, x), y), z) -> A_21_3 (A_7_4 (x, z), A_4_4 (y, z)) + A_36_4 (A_18_4 (A_4_8 (S, x), y), z) -> A_20_3 (A_8_4 (x, z), A_4_4 (y, z)) + A_36_4 (A_18_4 (A_4_10 (S, x), y), z) -> A_21_3 (A_10_4 (x, z), A_4_4 (y, z)) + A_36_4 (A_18_4 (A_4_13 (S, x), y), z) -> A_30_3 (A_13_4 (x, z), A_4_4 (y, z)) + A_36_4 (A_18_4 (A_4_14 (S, x), y), z) -> A_30_3 (A_14_4 (x, z), A_4_4 (y, z)) + A_36_4 (A_18_4 (A_4_15 (S, x), y), z) -> A_31_3 (A_15_4 (x, z), A_4_4 (y, z)) + A_36_4 (A_18_4 (A_4_16 (S, x), y), z) -> A_31_3 (A_16_4 (x, z), A_4_4 (y, z)) + A_36_4 (A_23_0 (A_4_19 (S, x), y), z) -> A_27_1 (A_19_4 (x, z), A_0_4 (y, z)) + A_36_4 (A_23_1 (A_4_19 (S, x), y), z) -> A_27_2 (A_19_4 (x, z), A_1_4 (y, z)) + A_36_4 (A_23_2 (A_4_19 (S, x), y), z) -> A_27_2 (A_19_4 (x, z), A_2_4 (y, z)) + A_36_4 (A_23_3 (A_4_19 (S, x), y), z) -> A_27_0 (A_19_4 (x, z), A_3_4 (y, z)) + A_36_4 (A_23_4 (A_4_19 (S, x), y), z) -> A_27_3 (A_19_4 (x, z), A_4_4 (y, z)) + A_36_4 (A_23_5 (A_4_19 (S, x), y), z) -> A_27_19 (A_19_4 (x, z), A_5_4 (y, z)) + A_36_4 (A_23_9 (A_4_19 (S, x), y), z) -> A_27_19 (A_19_4 (x, z), A_9_4 (y, z)) + A_36_4 (A_23_11 (A_4_19 (S, x), y), z) -> A_27_25 (A_19_4 (x, z), A_11_4 (y, z)) + A_36_4 (A_23_12 (A_4_19 (S, x), y), z) -> A_27_25 (A_19_4 (x, z), A_12_4 (y, z)) + A_36_4 (A_26_0 (A_4_20 (S, x), y), z) -> A_32_1 (A_20_4 (x, z), A_0_4 (y, z)) + A_36_4 (A_26_0 (A_4_21 (S, x), y), z) -> A_33_1 (A_21_4 (x, z), A_0_4 (y, z)) + A_36_4 (A_26_1 (A_4_20 (S, x), y), z) -> A_32_2 (A_20_4 (x, z), A_1_4 (y, z)) + A_36_4 (A_26_1 (A_4_21 (S, x), y), z) -> A_33_2 (A_21_4 (x, z), A_1_4 (y, z)) + A_36_4 (A_26_2 (A_4_20 (S, x), y), z) -> A_32_2 (A_20_4 (x, z), A_2_4 (y, z)) + A_36_4 (A_26_2 (A_4_21 (S, x), y), z) -> A_33_2 (A_21_4 (x, z), A_2_4 (y, z)) + A_36_4 (A_26_3 (A_4_20 (S, x), y), z) -> A_32_0 (A_20_4 (x, z), A_3_4 (y, z)) + A_36_4 (A_26_3 (A_4_21 (S, x), y), z) -> A_33_0 (A_21_4 (x, z), A_3_4 (y, z)) + A_36_4 (A_26_4 (A_4_20 (S, x), y), z) -> A_32_3 (A_20_4 (x, z), A_4_4 (y, z)) + A_36_4 (A_26_4 (A_4_21 (S, x), y), z) -> A_33_3 (A_21_4 (x, z), A_4_4 (y, z))) diff --git a/test/rel12.srs b/test/rel12.srs new file mode 100644 --- /dev/null +++ b/test/rel12.srs @@ -0,0 +1,6 @@ +(RULES +b p b -> a b a p b a, +p ->= a p a , +a p a ->= p +) + diff --git a/tpdb.cabal b/tpdb.cabal --- a/tpdb.cabal +++ b/tpdb.cabal @@ -1,7 +1,7 @@ -Cabal-Version: 2.4 +Cabal-Version: 3.0 Name: tpdb -Version: 2.3.0 +Version: 2.7.1 Author: Alexander Bau, Johannes Waldmann Maintainer: Johannes Waldmann @@ -20,9 +20,7 @@ Homepage: https://github.com/jwaldmann/haskell-tpdb -tested-with: GHC == 9.0.1 , GHC == 8.10.4 , GHC == 8.8.4 - , GHC == 8.6.5 , GHC == 8.4.4 - , GHC == 8.2.2 , GHC == 8.0.2 , GHC == 7.10.3 +tested-with: GHC == 9.6.2 Extra-Source-Files: test/*.xml, test/*.trs , test/*.srs, test/*.cpf @@ -38,7 +36,9 @@ Hs-Source-Dirs: src default-language: Haskell2010 Exposed-Modules: - TPDB.Data, TPDB.Data.Term, TPDB.Data.Rule, TPDB.Data.Attributes, TPDB.Data.Xml, + TPDB.Data, TPDB.Data.Identifier, + TPDB.Data.Term, TPDB.Data.Term.Plain, TPDB.Data.Term.Cached, + TPDB.Data.Rule, TPDB.Data.Attributes, TPDB.Data.Xml, -- TPDB.Compress, TPDB.Convert, TPDB.Input, TPDB.Input.File, TPDB.Input.Memory, TPDB.Mirror, @@ -59,6 +59,11 @@ main-is: srs2trs.hs default-language: Haskell2010 +Executable xtc2srs + build-depends: base==4.*, tpdb, bytestring + main-is: xtc2srs.hs + default-language: Haskell2010 + -- Executable Compressor -- Main-is: Compressor.hs -- Build-depends: base==4.*, containers >= 0.5, directory, wl-pprint-text, hxt, parsec, hashable @@ -155,3 +160,9 @@ hs-source-dirs: test default-language: Haskell2010 +Test-Suite dp-performance + Build-Depends: base==4.*, tpdb, text + Type: exitcode-stdio-1.0 + main-is: dp-performance.hs + hs-source-dirs: test + default-language: Haskell2010 diff --git a/xtc2srs.hs b/xtc2srs.hs new file mode 100644 --- /dev/null +++ b/xtc2srs.hs @@ -0,0 +1,13 @@ +import qualified TPDB.Data as D +import qualified TPDB.Input as I +import qualified TPDB.XTC as X +import qualified TPDB.Pretty as P +import System.Environment (getArgs) +import qualified Data.ByteString.Lazy.Char8 as L +import System.IO (stdout) + +main = do + [f] <- getArgs + s <- I.get_srs f + P.displayIO stdout $ P.renderWide $ P.pretty s +