From 2e341a80bcae5766f793d205e75cbd829e8ff209 Mon Sep 17 00:00:00 2001 From: ana-pantilie Date: Wed, 16 Sep 2020 12:44:02 +0300 Subject: [PATCH 1/7] And simplification: substitute function applications for constructors --- kore/src/Kore/Step/Simplification/And.hs | 32 ++++++++++++++++++------ 1 file changed, 25 insertions(+), 7 deletions(-) diff --git a/kore/src/Kore/Step/Simplification/And.hs b/kore/src/Kore/Step/Simplification/And.hs index 2fcbb7e3d8..8201f4622d 100644 --- a/kore/src/Kore/Step/Simplification/And.hs +++ b/kore/src/Kore/Step/Simplification/And.hs @@ -64,9 +64,15 @@ import qualified Kore.Internal.Predicate as Predicate import Kore.Internal.SideCondition ( SideCondition ) +import Kore.Internal.Symbol + ( isConstructor + , isFunction + ) import Kore.Internal.TermLike ( And (..) , pattern And_ + , pattern App_ + , pattern Equals_ , pattern Exists_ , pattern Forall_ , pattern Mu_ @@ -255,17 +261,29 @@ simplifyConjunctionByAssumption (Foldable.toList -> andPredicates) = :: Predicate variable -> StateT (HashMap (TermLike variable) (TermLike variable)) Changed () assume predicate1 = - State.modify' insert + State.modify' (insert termLike) where - insert = - case termLike of - -- Infer that the predicate is \bottom. - Not_ _ notChild -> HashMap.insert notChild (mkBottom sort) - -- Infer that the predicate is \top. - _ -> HashMap.insert termLike (mkTop sort) + insert (Not_ _ notChild) = + -- Infer that the predicate is \bottom. + HashMap.insert notChild (mkBottom sort) + insert + term@( + Equals_ _ _ + child1@(App_ symbol1 _) + child2@(App_ symbol2 _) + ) + | isConstructor symbol1, isFunction symbol2 = + HashMap.insert child2 child1 + | isConstructor symbol2, isFunction symbol1 = + HashMap.insert child1 child2 + -- Infer that the predicate is \top. + | otherwise = HashMap.insert term (mkTop sort) + insert term = HashMap.insert term (mkTop sort) + termLike = Predicate.unwrapPredicate predicate1 sort = termLikeSort termLike + applyAssumptions :: TermLike variable -> StateT (HashMap (TermLike variable) (TermLike variable)) Changed From 21fe074f9379ea782f9a4afb046f51e16966c87d Mon Sep 17 00:00:00 2001 From: ana-pantilie Date: Wed, 16 Sep 2020 14:25:22 +0300 Subject: [PATCH 2/7] Add unit tests --- kore/src/Kore/Step/Simplification/And.hs | 1 - .../test/Test/Kore/Step/Simplification/And.hs | 136 ++++++++++++++++-- 2 files changed, 123 insertions(+), 14 deletions(-) diff --git a/kore/src/Kore/Step/Simplification/And.hs b/kore/src/Kore/Step/Simplification/And.hs index 8201f4622d..00cfa1ba1a 100644 --- a/kore/src/Kore/Step/Simplification/And.hs +++ b/kore/src/Kore/Step/Simplification/And.hs @@ -283,7 +283,6 @@ simplifyConjunctionByAssumption (Foldable.toList -> andPredicates) = termLike = Predicate.unwrapPredicate predicate1 sort = termLikeSort termLike - applyAssumptions :: TermLike variable -> StateT (HashMap (TermLike variable) (TermLike variable)) Changed diff --git a/kore/test/Test/Kore/Step/Simplification/And.hs b/kore/test/Test/Kore/Step/Simplification/And.hs index 47d11efec4..74f577f95e 100644 --- a/kore/test/Test/Kore/Step/Simplification/And.hs +++ b/kore/test/Test/Kore/Step/Simplification/And.hs @@ -8,9 +8,7 @@ import Test.Tasty import qualified Kore.Internal.Condition as Condition import qualified Kore.Internal.MultiAnd as MultiAnd -import Kore.Internal.MultiOr - ( MultiOr (MultiOr) - ) +import qualified Kore.Internal.MultiOr as MultiOr import Kore.Internal.OrPattern ( OrPattern ) @@ -276,7 +274,7 @@ test_andSimplification = [(inject Mock.y, fOfX)] } actual <- evaluatePatterns yExpanded fOfXExpanded - assertEqual "" (MultiOr [expect]) actual + assertEqual "" (MultiOr.make [expect]) actual , testCase "term-variable" $ do let expect = @@ -287,7 +285,7 @@ test_andSimplification = [(inject Mock.y, fOfX)] } actual <- evaluatePatterns fOfXExpanded yExpanded - assertEqual "" (MultiOr [expect]) actual + assertEqual "" (MultiOr.make [expect]) actual ] , testGroup "constructor and" @@ -310,7 +308,7 @@ test_andSimplification = , predicate = makeTruePredicate_ , substitution = mempty } - assertEqual "" (MultiOr [expect]) actual + assertEqual "" (MultiOr.make [expect]) actual , testCase "different constructors" $ do actual <- @@ -325,7 +323,7 @@ test_andSimplification = , predicate = makeTruePredicate_ , substitution = mempty } - assertEqual "" (MultiOr []) actual + assertEqual "" (MultiOr.make []) actual ] -- (a or b) and (c or d) = (b and d) or (b and c) or (a and d) or (a and c) @@ -395,7 +393,7 @@ test_andSimplification = , predicate = makeCeilPredicate_ fOfX , substitution = mempty } - assertEqual "" (MultiOr [expect]) actual + assertEqual "" (MultiOr.make [expect]) actual , testCase "Contradictions result in bottom" $ do actual <- evaluatePatterns @@ -436,7 +434,7 @@ test_andSimplification = (makeCeilPredicate_ gOfX) , substitution = mempty } - assertEqual "" (MultiOr [expect]) actual + assertEqual "" (MultiOr.make [expect]) actual , testCase "Simplifies Implies - Negative" $ do let expect = Conditional @@ -462,7 +460,7 @@ test_andSimplification = (makeCeilPredicate_ gOfX) , substitution = mempty } - assertEqual "" (MultiOr [expect]) actual + assertEqual "" (MultiOr.make [expect]) actual , testCase "Simplifies multiple Implies" $ do let expect = Conditional @@ -497,7 +495,7 @@ test_andSimplification = ) , substitution = mempty } - assertEqual "" (MultiOr [expect]) actual + assertEqual "" (MultiOr.make [expect]) actual , testCase "Does not replace and terms under intersecting quantifiers" $ do let expect = Conditional @@ -523,7 +521,7 @@ test_andSimplification = makeExistsPredicate Mock.x (makeCeilPredicate_ fOfX) , substitution = mempty } - assertEqual "" (MultiOr [expect]) actual + assertEqual "" (MultiOr.make [expect]) actual , testCase "Replaces and terms under independent quantifiers" $ do let expect = Conditional @@ -553,7 +551,119 @@ test_andSimplification = ) , substitution = mempty } - assertEqual "" (MultiOr [expect]) actual + assertEqual "" (MultiOr.make [expect]) actual + , testCase "Function application equals different constructors 1" $ do + let functionApplication = Mock.f (mkElemVar Mock.x) + definednessCondition = makeCeilPredicate_ functionApplication + actual <- + evaluatePatterns + ( makeAndPredicate + definednessCondition + (makeEqualsPredicate_ + functionApplication + Mock.a + ) + & Condition.fromPredicate + & Pattern.fromCondition_ + ) + ( makeAndPredicate + definednessCondition + (makeEqualsPredicate_ + functionApplication + Mock.b + ) + & Condition.fromPredicate + & Pattern.fromCondition_ + ) + assertEqual "" (MultiOr.make []) actual + , testCase "Function application equals different constructors 2" $ do + let functionApplication = Mock.f (mkElemVar Mock.x) + definednessCondition = makeCeilPredicate_ functionApplication + actual <- + evaluatePatterns + ( makeAndPredicate + definednessCondition + (makeEqualsPredicate_ + Mock.a + functionApplication + ) + & Condition.fromPredicate + & Pattern.fromCondition_ + ) + ( makeAndPredicate + definednessCondition + (makeEqualsPredicate_ + functionApplication + Mock.b + ) + & Condition.fromPredicate + & Pattern.fromCondition_ + ) + assertEqual "" (MultiOr.make []) actual + , testCase "Function application equals different constructors 3" $ do + let functionApplication = Mock.f (mkElemVar Mock.x) + definednessCondition = makeCeilPredicate_ functionApplication + actual <- + evaluatePatterns + ( makeAndPredicate + definednessCondition + (makeEqualsPredicate_ + Mock.a + functionApplication + ) + & Condition.fromPredicate + & Pattern.fromCondition_ + ) + ( makeAndPredicate + definednessCondition + (makeEqualsPredicate_ + Mock.b + functionApplication + ) + & Condition.fromPredicate + & Pattern.fromCondition_ + ) + assertEqual "" (MultiOr.make []) actual + , testCase "Function application equals different constructors 4" $ do + let functionApplication = Mock.f (mkElemVar Mock.x) + definednessCondition = makeCeilPredicate_ functionApplication + actual <- + evaluatePatterns + ( makeAndPredicate + definednessCondition + (makeEqualsPredicate_ + functionApplication + Mock.a + ) + & Condition.fromPredicate + & Pattern.fromCondition_ + ) + ( makeAndPredicate + definednessCondition + (makeEqualsPredicate_ + Mock.b + functionApplication + ) + & Condition.fromPredicate + & Pattern.fromCondition_ + ) + assertEqual "" (MultiOr.make []) actual + , testCase "Constructor equality" $ do + actual <- + evaluatePatterns + (makeEqualsPredicate_ + Mock.c + Mock.a + & Condition.fromPredicate + & Pattern.fromCondition_ + ) + ( makeEqualsPredicate_ + Mock.b + Mock.c + & Condition.fromPredicate + & Pattern.fromCondition_ + ) + assertEqual "" (MultiOr.make []) actual ] where yExpanded = Conditional From 6dfbde3804ddeb7d8f8ca7ea738f249cb42ad12f Mon Sep 17 00:00:00 2001 From: Thomas Tuegel Date: Fri, 18 Sep 2020 11:50:48 -0500 Subject: [PATCH 3/7] simplifyConjunctionByAssumption: Refactor --- kore/src/Kore/Step/Simplification/And.hs | 34 ++++++++++++------------ 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/kore/src/Kore/Step/Simplification/And.hs b/kore/src/Kore/Step/Simplification/And.hs index 00cfa1ba1a..a31c22efbf 100644 --- a/kore/src/Kore/Step/Simplification/And.hs +++ b/kore/src/Kore/Step/Simplification/And.hs @@ -261,24 +261,24 @@ simplifyConjunctionByAssumption (Foldable.toList -> andPredicates) = :: Predicate variable -> StateT (HashMap (TermLike variable) (TermLike variable)) Changed () assume predicate1 = - State.modify' (insert termLike) + State.modify' (assumeEqualTerms . assumePredicate) where - insert (Not_ _ notChild) = - -- Infer that the predicate is \bottom. - HashMap.insert notChild (mkBottom sort) - insert - term@( - Equals_ _ _ - child1@(App_ symbol1 _) - child2@(App_ symbol2 _) - ) - | isConstructor symbol1, isFunction symbol2 = - HashMap.insert child2 child1 - | isConstructor symbol2, isFunction symbol1 = - HashMap.insert child1 child2 - -- Infer that the predicate is \top. - | otherwise = HashMap.insert term (mkTop sort) - insert term = HashMap.insert term (mkTop sort) + assumePredicate = + case termLike of + Not_ _ notChild -> + -- Infer that the predicate is \bottom. + HashMap.insert notChild (mkBottom sort) + _ -> + -- Infer that the predicate is \top. + HashMap.insert termLike (mkTop sort) + assumeEqualTerms = + case termLike of + Equals_ _ _ term1@(App_ symbol1 _) term2@(App_ symbol2 _) + | isConstructor symbol1, isFunction symbol2 -> + HashMap.insert term2 term1 + | isConstructor symbol2, isFunction symbol1 -> + HashMap.insert term1 term2 + _ -> id termLike = Predicate.unwrapPredicate predicate1 sort = termLikeSort termLike From cbf71a2779d1d1e35d0b0ecc7001faa8e2517861 Mon Sep 17 00:00:00 2001 From: Thomas Tuegel Date: Tue, 22 Sep 2020 08:31:19 -0500 Subject: [PATCH 4/7] retractLocalFunction: Extrac from simplifyConjunctionByAssumption --- kore/src/Kore/Step/Simplification/And.hs | 32 +++++++++++++++++++----- 1 file changed, 26 insertions(+), 6 deletions(-) diff --git a/kore/src/Kore/Step/Simplification/And.hs b/kore/src/Kore/Step/Simplification/And.hs index a31c22efbf..473ddb976a 100644 --- a/kore/src/Kore/Step/Simplification/And.hs +++ b/kore/src/Kore/Step/Simplification/And.hs @@ -102,6 +102,7 @@ import Kore.Unparser ( unparse ) import Logic +import Pair import qualified Pretty {- | Simplify a conjunction of 'OrPattern'. @@ -272,12 +273,8 @@ simplifyConjunctionByAssumption (Foldable.toList -> andPredicates) = -- Infer that the predicate is \top. HashMap.insert termLike (mkTop sort) assumeEqualTerms = - case termLike of - Equals_ _ _ term1@(App_ symbol1 _) term2@(App_ symbol2 _) - | isConstructor symbol1, isFunction symbol2 -> - HashMap.insert term2 term1 - | isConstructor symbol2, isFunction symbol1 -> - HashMap.insert term1 term2 + case retractLocalFunction termLike of + Just (Pair term1 term2) -> HashMap.insert term1 term2 _ -> id termLike = Predicate.unwrapPredicate predicate1 @@ -340,6 +337,29 @@ simplifyConjunctionByAssumption (Foldable.toList -> andPredicates) = where wouldNotCapture = not . TermLike.hasFreeVariable variableName +{- | Get a local function definition from a 'TermLike'. + +A local function definition is a predicate that we can use to evaluate a +function locally (based on the side conditions) when none of the functions +global definitions (axioms) apply. We are looking for a 'TermLike' of the form + +@ +\equals(f(...), C(...)) +@ + +where @f@ is a function and @C@ is a constructor. @retractLocalFunction@ will +match an @\equals@ predicate with its arguments in either order, but the +function pattern is always returned first in the 'Pair'. + + -} +retractLocalFunction + :: TermLike variable + -> Maybe (Pair (TermLike variable)) +retractLocalFunction (Equals_ _ _ term1@(App_ symbol1 _) term2@(App_ symbol2 _)) + | isConstructor symbol1, isFunction symbol2 = Just (Pair term2 term1) + | isConstructor symbol2, isFunction symbol1 = Just (Pair term1 term2) +retractLocalFunction _ = Nothing + applyAndIdempotenceAndFindContradictions :: InternalVariable variable => TermLike variable From c336a7696bf4c58fca41a8d4914182c0e325694f Mon Sep 17 00:00:00 2001 From: Thomas Tuegel Date: Tue, 22 Sep 2020 08:54:29 -0500 Subject: [PATCH 5/7] Test.Kore.Step.Simplification.And: Refactor function evaluation tests --- .../test/Test/Kore/Step/Simplification/And.hs | 117 ++++-------------- 1 file changed, 21 insertions(+), 96 deletions(-) diff --git a/kore/test/Test/Kore/Step/Simplification/And.hs b/kore/test/Test/Kore/Step/Simplification/And.hs index 74f577f95e..c461bb10a6 100644 --- a/kore/test/Test/Kore/Step/Simplification/And.hs +++ b/kore/test/Test/Kore/Step/Simplification/And.hs @@ -552,102 +552,27 @@ test_andSimplification = , substitution = mempty } assertEqual "" (MultiOr.make [expect]) actual - , testCase "Function application equals different constructors 1" $ do - let functionApplication = Mock.f (mkElemVar Mock.x) - definednessCondition = makeCeilPredicate_ functionApplication - actual <- - evaluatePatterns - ( makeAndPredicate - definednessCondition - (makeEqualsPredicate_ - functionApplication - Mock.a - ) - & Condition.fromPredicate - & Pattern.fromCondition_ - ) - ( makeAndPredicate - definednessCondition - (makeEqualsPredicate_ - functionApplication - Mock.b - ) - & Condition.fromPredicate - & Pattern.fromCondition_ - ) - assertEqual "" (MultiOr.make []) actual - , testCase "Function application equals different constructors 2" $ do - let functionApplication = Mock.f (mkElemVar Mock.x) - definednessCondition = makeCeilPredicate_ functionApplication - actual <- - evaluatePatterns - ( makeAndPredicate - definednessCondition - (makeEqualsPredicate_ - Mock.a - functionApplication - ) - & Condition.fromPredicate - & Pattern.fromCondition_ - ) - ( makeAndPredicate - definednessCondition - (makeEqualsPredicate_ - functionApplication - Mock.b - ) - & Condition.fromPredicate - & Pattern.fromCondition_ - ) - assertEqual "" (MultiOr.make []) actual - , testCase "Function application equals different constructors 3" $ do - let functionApplication = Mock.f (mkElemVar Mock.x) - definednessCondition = makeCeilPredicate_ functionApplication - actual <- - evaluatePatterns - ( makeAndPredicate - definednessCondition - (makeEqualsPredicate_ - Mock.a - functionApplication - ) - & Condition.fromPredicate - & Pattern.fromCondition_ - ) - ( makeAndPredicate - definednessCondition - (makeEqualsPredicate_ - Mock.b - functionApplication - ) - & Condition.fromPredicate - & Pattern.fromCondition_ - ) - assertEqual "" (MultiOr.make []) actual - , testCase "Function application equals different constructors 4" $ do - let functionApplication = Mock.f (mkElemVar Mock.x) - definednessCondition = makeCeilPredicate_ functionApplication - actual <- - evaluatePatterns - ( makeAndPredicate - definednessCondition - (makeEqualsPredicate_ - functionApplication - Mock.a - ) - & Condition.fromPredicate - & Pattern.fromCondition_ - ) - ( makeAndPredicate - definednessCondition - (makeEqualsPredicate_ - Mock.b - functionApplication - ) - & Condition.fromPredicate - & Pattern.fromCondition_ - ) - assertEqual "" (MultiOr.make []) actual + , testGroup "Local function evaluation" $ + let f = Mock.f (mkElemVar Mock.x) + defined = makeCeilPredicate_ f & Condition.fromPredicate + a = Mock.a + b = Mock.b + mkLocalDefn (Left t) = makeEqualsPredicate_ t f + mkLocalDefn (Right t) = makeEqualsPredicate_ f t + test name eitherC1 eitherC2 = + testCase name $ do + let equals1 = mkLocalDefn eitherC1 & Condition.fromPredicate + equals2 = mkLocalDefn eitherC2 & Condition.fromPredicate + pattern1 = Pattern.fromCondition_ (defined <> equals1) + pattern2 = Pattern.fromCondition_ (defined <> equals2) + actual <- evaluatePatterns pattern1 pattern2 + assertBool "Expected \\bottom" $ isBottom actual + in + [ test "contradiction: f(x) = a ∧ f(x) = b" (Right a) (Right b) + , test "contradiction: a = f(x) ∧ f(x) = b" (Left a) (Right b) + , test "contradiction: a = f(x) ∧ b = f(x)" (Left a) (Left b) + , test "contradiction: f(x) = a ∧ b = f(x)" (Right a) (Left b) + ] , testCase "Constructor equality" $ do actual <- evaluatePatterns From e37aaa73f24c835f3fee8d717019fd9abd1e351c Mon Sep 17 00:00:00 2001 From: ana-pantilie Date: Tue, 22 Sep 2020 17:42:51 +0300 Subject: [PATCH 6/7] Add issue-2095 test --- test/issue-2095/Makefile | 3 + test/issue-2095/definition.kore | 29124 ++++++++++++++++ test/issue-2095/pgm.kore | 1 + test/issue-2095/searchFile.kore | 1 + test/issue-2095/test-issue-2095.sh | 2 + test/issue-2095/test-issue-2095.sh.out.golden | 10526 ++++++ 6 files changed, 39657 insertions(+) create mode 100644 test/issue-2095/Makefile create mode 100644 test/issue-2095/definition.kore create mode 100644 test/issue-2095/pgm.kore create mode 100644 test/issue-2095/searchFile.kore create mode 100755 test/issue-2095/test-issue-2095.sh create mode 100644 test/issue-2095/test-issue-2095.sh.out.golden diff --git a/test/issue-2095/Makefile b/test/issue-2095/Makefile new file mode 100644 index 0000000000..0cc28305ba --- /dev/null +++ b/test/issue-2095/Makefile @@ -0,0 +1,3 @@ +include $(CURDIR)/../include.mk + +test-%.sh.out: $(TEST_DIR)/test-%-* diff --git a/test/issue-2095/definition.kore b/test/issue-2095/definition.kore new file mode 100644 index 0000000000..6ed0171dfa --- /dev/null +++ b/test/issue-2095/definition.kore @@ -0,0 +1,29124 @@ +[topCellInitializer{}(LblinitGeneratedTopCell{}())] + +module BASIC-K + sort SortK{} [] + sort SortKItem{} [] +endmodule [] + +module KSEQ + import BASIC-K [] + + // TODO: Provide constructor and functional axioms for `kseq` and `dotk`. + symbol kseq{}(SortKItem{}, SortK{}) : SortK{} [constructor{}(),functional{}()] + symbol dotk{}() : SortK{} [constructor{}(),functional{}()] + + symbol append{}(SortK{}, SortK{}) : SortK{} [function{}()] + + axiom{R} + \equals{SortK{},R}( + append{}(dotk{}(),K2:SortK{}), + K2:SortK{}) + [] + + axiom{R} + \equals{SortK{},R}( + append{}(kseq{}(K1:SortKItem{},K2:SortK{}),K3:SortK{}), + kseq{}(K1:SortKItem{},append{}(K2:SortK{},K3:SortK{}))) + [] + +endmodule [] + +module INJ + symbol inj{From,To}(From) : To [sortInjection{}()] + + axiom{S1,S2,S3,R} + \equals{S3,R}( + inj{S2,S3}(inj{S1,S2}(T:S1)), + inj{S1,S3}(T:S1)) + [] + +endmodule [] + +module K + import KSEQ [] + import INJ [] + + // Defnitions for reachability aliases + // Until we will have `mu` we resort to dummy definitions + alias weakExistsFinally{A}(A) : A + where weakExistsFinally{A}(@X:A) := @X:A [] + + alias weakAlwaysFinally{A}(A) : A + where weakAlwaysFinally{A}(@X:A) := @X:A [] + + // Definitions for CTL aliases + // Until we will have `mu` we resort to dummy definitions + alias allPathGlobally{A}(A) : A + where allPathGlobally{A}(@X:A) := @X:A [] + +endmodule [] + +module MICHELSON + +// imports + import K [] + +// sorts + sort SortSymbolicElement{} [] + sort SortMynowCellOpt{} [] + sort SortMyamountCell{} [] + sort SortBlockList{} [] + sort SortSymbolsCellOpt{} [] + sort SortUnifiedSet{} [] + sort SortMutez{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(41,3,41,14)")] + sort SortTypeAnnotation{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(69,3,69,35)"), token{}(), hasDomainValues{}()] + sort SortMaybeTypeName{} [] + sort SortData{} [org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(33,3,33,13)"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)")] + sort SortInternalStack{} [] + sort SortOtherContractsMapEntryList{} [] + sort SortSimpleData{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(31,3,31,19)")] + sort SortBigmapsCellOpt{} [] + sort SortKCellOpt{} [] + sort SortContractsGroup{} [] + sort SortNumTypeName{} [] + sort SortSelfGroup{} [] + sort SortPreCell{} [] + sort SortOtherContractsMapEntry{} [] + sort SortNowGroup{} [] + sort SortPreCellOpt{} [] + sort SortInputstackCellOpt{} [] + sort SortSourceGroup{} [] + sort SortBoolExp{} [] + sort SortUnifiedList{} [] + sort SortPostCell{} [] + sort SortCodeDecl{} [] + sort SortTraceCellOpt{} [] + sort SortOperationNonce{} [] + sort SortLambdaData{} [] + sort SortParamvalueCellOpt{} [] + sort SortIOInt{} [] + sort SortStoragetypeCellOpt{} [] + sort SortStackElementLiteral{} [] + sort SortPreconditionGroup{} [] + sort SortMichelsonBool{} [hasDomainValues{}()] + sort SortParameterValueGroup{} [] + sort SortStackCell{} [] + sort SortNullaryTypeName{} [] + sort SortMychainidCellOpt{} [] + sort SortTypedData{} [] + sort SortMichelsonTopCellOpt{} [] + sort SortGeneratedTopCellFragment{} [] + sort SortInstruction{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(34,3,34,20)")] + sort SortIOFile{} [] + hooked-sort SortList{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), element{}(LblListItem{}()), concat{}(Lbl'Unds'List'Unds'{}()), unit{}(Lbl'Stop'List{}()), hook{}("LIST.List"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(595,3,595,31)")] + sort SortMapTypeName{} [] + sort SortSimpleType{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(38,3,38,19)")] + sort SortKCell{} [] + sort SortParameterGroup{} [] + sort SortTypeName{} [] + sort SortGroup{} [] + sort SortAssumeFailedCellOpt{} [] + sort SortStackElement{} [] + sort SortExpectedCell{} [] + sort SortStoragevalueCellOpt{} [] + sort SortChainId{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(43,3,43,16)")] + sort SortGeneratedTopCell{} [] + sort SortCutpointsCell{} [] + sort SortStorageDecl{} [] + sort SortGeneratedCounterCell{} [] + sort SortKnownaddrsCell{} [] + sort SortContract{} [org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(36,3,36,17)"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)")] + sort SortDataOrSeq{} [] + sort SortInputGroup{} [] + sort SortOrData{} [] + sort SortInvsCell{} [] + sort SortAnnotation{} [] + sort SortPair{} [] + sort SortInputstackCell{} [] + sort SortAmountGroup{} [] + sort SortMichelsonTopCellFragment{} [] + sort SortParamtypeCellOpt{} [] + sort SortSignedness{} [] + hooked-sort SortFloat{} [org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1120,3,1120,34)"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), hook{}("FLOAT.Float"), hasDomainValues{}()] + sort SortMybalanceCellOpt{} [] + sort SortSenderGroup{} [] + sort SortKeyHash{} [org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(42,3,42,16)"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)")] + sort SortContractGroup{} [] + sort SortLiteralStack{} [] + sort SortBalanceGroup{} [] + hooked-sort SortMap{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), element{}(Lbl'UndsPipe'-'-GT-Unds'{}()), concat{}(Lbl'Unds'Map'Unds'{}()), unit{}(Lbl'Stop'Map{}()), hook{}("MAP.Map"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(219,3,219,28)")] + sort SortError{} [] + hooked-sort SortString{} [org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1330,3,1330,37)"), hook{}("STRING.String"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), hasDomainValues{}()] + sort SortMyaddrCell{} [] + sort SortBigMapEntry{} [] + sort SortStoragevalueCell{} [] + sort SortIOString{} [] + sort SortId{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), token{}(), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1916,3,1916,19)"), hasDomainValues{}()] + sort SortBlock{} [] + sort SortBigMapEntryList{} [] + sort SortGeneratedCounterCellOpt{} [] + sort SortCodeGroup{} [] + sort SortBigmapsCell{} [] + sort SortMychainidCell{} [] + sort SortPreData{} [] + sort SortNonceCellOpt{} [] + sort SortBinaryTypeName{} [] + sort SortDataList{} [] + sort SortSourceaddrCellOpt{} [] + sort SortAnnotationList{} [] + sort SortKConfigVar{} [org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(39,3,39,27)"), token{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/kast.md)"), hasDomainValues{}()] + sort SortParamtypeCell{} [] + sort SortEmptyBlock{} [] + sort SortSequenceData{} [] + sort SortScriptCell{} [] + sort SortAssumeFailedCell{} [] + sort SortInvsCellOpt{} [] + sort SortBigMapGroup{} [] + sort SortInvariantsGroup{} [] + hooked-sort SortInt{} [org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(848,3,848,28)"), hook{}("INT.Int"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), hasDomainValues{}()] + sort SortPreType{} [] + sort SortExpectedCellOpt{} [] + sort SortPostconditionGroup{} [] + sort SortIOError{} [] + sort SortSenderaddrCell{} [] + sort SortStorageValueGroup{} [] + sort SortCutpointsCellOpt{} [] + sort SortKey{} [org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(45,3,45,12)"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)")] + sort SortTraceCell{} [] + sort SortMBytesLiteral{} [hasDomainValues{}()] + hooked-sort SortSet{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), element{}(LblSetItem{}()), concat{}(Lbl'Unds'Set'Unds'{}()), unit{}(Lbl'Stop'Set{}()), hook{}("SET.Set"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(470,3,470,28)")] + sort SortFieldAnnotation{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), token{}(), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(71,3,71,35)"), hasDomainValues{}()] + sort SortPgm{} [] + sort SortReturncodeCell{} [] + sort SortFailedStack{} [] + sort SortMichelsonTopCell{} [] + sort SortPostCellOpt{} [] + sort SortMapEntry{} [] + sort SortSymbolicData{} [org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(739,3,739,29)"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), token{}(), hasDomainValues{}()] + sort SortNonceCell{} [] + sort SortParamvalueCell{} [] + sort SortTimestamp{} [org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(44,3,44,18)"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)")] + sort SortOptionData{} [] + sort SortStack{} [] + hooked-sort SortBytes{} [hasDomainValues{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), token{}(), hook{}("BYTES.Bytes"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1607,3,1607,41)")] + sort SortSymbolsCell{} [] + sort SortOutputStack{} [] + sort SortStackCellOpt{} [] + sort SortReturncodeCellOpt{} [] + sort SortUnaryTypeName{} [] + sort SortSenderaddrCellOpt{} [] + sort SortParameterDecl{} [] + sort SortEndianness{} [] + sort SortInvariant{} [] + sort SortMapEntryList{} [] + sort SortMyaddrCellOpt{} [] + sort SortType{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)")] + sort SortGroups{} [] + sort SortMyamountCellOpt{} [] + sort SortStoragetypeCell{} [] + sort SortMynowCell{} [] + sort SortStackElementList{} [] + sort SortVariableAnnotation{} [org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(70,3,70,35)"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), token{}(), hasDomainValues{}()] + sort SortKResult{} [] + sort SortAddress{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(39,3,39,16)")] + sort SortChainGroup{} [] + sort SortTypedSymbol{} [] + sort SortStream{} [] + sort SortSignature{} [org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(46,3,46,18)"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)")] + sort SortCell{} [] + sort SortScriptCellOpt{} [] + sort SortSourceaddrCell{} [] + sort SortContractData{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(40,3,40,21)")] + sort SortMapLiteral{} [] + hooked-sort SortBool{} [hook{}("BOOL.Bool"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(750,3,750,31)"), hasDomainValues{}()] + sort SortKnownaddrsCellOpt{} [] + sort SortOutputGroup{} [] + sort SortMybalanceCell{} [] + sort SortMBytes{} [] + sort SortUnificationFailure{} [] + sort SortBlockchainOperation{} [] + sort SortMapOpInfo{} [] + +// symbols + symbol Lbl'Hash'Address'LParUndsRParUnds'MICHELSON-COMMON'Unds'Address'Unds'String{}(SortString{}) : SortAddress{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#Address"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(90,22,90,37)"), left{}(), format{}("%c#Address%r %c(%r %1 %c)%r"), injective{}()] + symbol Lbl'Hash'AllTypesKnown'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'Set{}(SortSet{}) : SortBool{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#AllTypesKnown"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2205,19,2205,60)"), left{}(), format{}("%c#AllTypesKnown%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'Any'Unds'UNIT-TEST-COMMON-SYNTAX'Unds'Data{}() : SortData{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(669,19,669,24)"), left{}(), format{}("%c#Any%r"), injective{}()] + symbol Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(SortBoolExp{}) : SortKItem{} [functional{}(), constructor{}(), strict{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), result{}("Bool"), right{}(), terminals{}("1101"), klabel{}("#Assert"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1971,20,1971,58)"), left{}(), format{}("%c#Assert%r %c(%r %1 %c)%r"), injective{}()] + symbol Lbl'Hash'AssertFailed{}() : SortKItem{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#AssertFailed"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1974,20,1974,66)"), left{}(), format{}("%c#AssertFailed%r"), injective{}()] + symbol Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}() : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1959,26,1959,38)"), left{}(), format{}("%c#AssertTrue%r"), injective{}()] + symbol Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(SortBoolExp{}) : SortKItem{} [functional{}(), constructor{}(), strict{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), result{}("Bool"), right{}(), terminals{}("1101"), klabel{}("#Assume"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1978,20,1978,58)"), left{}(), format{}("%c#Assume%r %c(%r %1 %c)%r"), injective{}()] + symbol Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}() : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1965,26,1965,38)"), left{}(), format{}("%c#AssumeTrue%r"), injective{}()] + symbol Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(SortSequenceData{}, SortType{}) : SortKItem{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("110101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(465,20,465,58)"), left{}(), format{}("%c#BigMap%r %c(%r %1 %c,%r %2 %c)%r"), injective{}()] + symbol Lbl'Hash'BigMapsEntryListToKMap'LParUndsRParUnds'MICHELSON'Unds'Map'Unds'BigMapEntryList{}(SortBigMapEntryList{}) : SortMap{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#BigMapsEntryListToKMap"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(459,18,459,68)"), left{}(), format{}("%c#BigMapsEntryListToKMap%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'BigMapsEntryToKMap'LParUndsRParUnds'MICHELSON'Unds'Map'Unds'BigMapEntry{}(SortBigMapEntry{}) : SortMap{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#BigMapsEntryToKMap"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(460,18,460,60)"), left{}(), format{}("%c#BigMapsEntryToKMap%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(SortInternalStack{}, SortInternalStack{}) : SortKItem{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("#Bind"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2072,20,2072,54)"), left{}(), format{}("%c#Bind%r %c(%r %1 %c,%r %2 %c)%r"), injective{}()] + symbol Lbl'Hash'Blake2B'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(SortMBytes{}) : SortMBytes{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#Blake2B"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(118,21,118,36)"), left{}(), format{}("%c#Blake2B%r %c(%r %1 %c)%r"), injective{}()] + symbol Lbl'Hash'Blake2BKeyHash'LParUndsRParUnds'MICHELSON'Unds'String'Unds'String{}(SortString{}) : SortString{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#Blake2BKeyHash"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1781,21,1781,54)"), left{}(), format{}("%c#Blake2BKeyHash%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'ChainId'LParUndsRParUnds'MICHELSON-COMMON'Unds'ChainId'Unds'MBytes{}(SortMBytes{}) : SortChainId{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#ChainId"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(94,22,94,37)"), left{}(), format{}("%c#ChainId%r %c(%r %1 %c)%r"), injective{}()] + symbol Lbl'Hash'CompatibleTypes'LParUndsCommUndsRParUnds'MICHELSON'Unds'Bool'Unds'MaybeTypeName'Unds'TypeName{}(SortMaybeTypeName{}, SortTypeName{}) : SortBool{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("#CompatibleTypes"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1520,19,1520,70)"), left{}(), format{}("%c#CompatibleTypes%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + symbol Lbl'Hash'ConcatBytes'LParUndsCommUndsRParUnds'MICHELSON'Unds'Bytes'Unds'List'Unds'Bytes{}(SortList{}, SortBytes{}) : SortBytes{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("#ConcatBytes"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1284,20,1284,55)"), left{}(), format{}("%c#ConcatBytes%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + symbol Lbl'Hash'ConcatStrings'LParUndsCommUndsRParUnds'MICHELSON'Unds'String'Unds'List'Unds'String{}(SortList{}, SortString{}) : SortString{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("#ConcatStrings"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1222,21,1222,59)"), left{}(), format{}("%c#ConcatStrings%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + symbol Lbl'Hash'ConcreteMatch'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Bool'Unds'Data'Unds'Type'Unds'Map'Unds'Map'Unds'Data{}(SortData{}, SortType{}, SortMap{}, SortMap{}, SortData{}, SortGeneratedTopCell{}) : SortBool{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101010101010"), klabel{}("#ConcreteMatch"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2107,19,2107,71)"), left{}(), format{}("%c#ConcreteMatch%r %c(%r %1 %c,%r %2 %c,%r %3 %c,%r %4 %c,%r %5 %c)%r %6"), function{}()] + symbol Lbl'Hash'Contract'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'ContractData'Unds'Address'Unds'Type{}(SortAddress{}, SortType{}) : SortContractData{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("#Contract"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(91,27,91,50)"), left{}(), format{}("%c#Contract%r %c(%r %1 %c,%r %2 %c)%r"), injective{}()] + symbol Lbl'Hash'ConvertBigMapsToNative'LParUndsRParUnds'MICHELSON'Unds'Map'Unds'Map{}(SortMap{}, SortGeneratedTopCell{}) : SortMap{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("11010"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(521,18,521,65)"), left{}(), format{}("%c#ConvertBigMapsToNative%r %c(%r %1 %c)%r %2"), function{}()] + symbol Lbl'Hash'ConvertBigMapsToNative'Unds'MICHELSON'Unds'KItem{}() : SortKItem{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(516,20,516,44)"), left{}(), format{}("%c#ConvertBigMapsToNative%r"), injective{}()] + symbol Lbl'Hash'ConvertParamToNative'Unds'MICHELSON'Unds'KItem{}() : SortKItem{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(529,20,529,42)"), left{}(), format{}("%c#ConvertParamToNative%r"), injective{}()] + symbol Lbl'Hash'ConvertStorageToNative'Unds'MICHELSON'Unds'KItem{}() : SortKItem{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(539,20,539,44)"), left{}(), format{}("%c#ConvertStorageToNative%r"), injective{}()] + symbol Lbl'Hash'ConvertToType'LParUndsRParUnds'MICHELSON'Unds'Type'Unds'PreType{}(SortPreType{}) : SortType{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#ConvertToType"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(549,19,549,52)"), left{}(), format{}("%c#ConvertToType%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(SortSymbolicData{}, SortType{}) : SortKItem{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("#CreateSymbol"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2250,20,2250,52)"), left{}(), format{}("%c#CreateSymbol%r %c(%r %1 %c,%r %2 %c)%r"), injective{}()] + symbol Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(SortUnifiedList{}) : SortKItem{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#CreateSymbols"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2240,20,2240,46)"), left{}(), format{}("%c#CreateSymbols%r %c(%r %1 %c)%r"), injective{}()] + symbol Lbl'Hash'CreateSymbols'Unds'MICHELSON'Unds'KItem{}() : SortKItem{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(493,20,493,35)"), left{}(), format{}("%c#CreateSymbols%r"), injective{}()] + symbol Lbl'Hash'DefaultType'LParUndsCommUndsRParUnds'MICHELSON'Unds'TypeName'Unds'MaybeTypeName'Unds'TypeName{}(SortMaybeTypeName{}, SortTypeName{}) : SortTypeName{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("#DefaultType"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1525,23,1525,70)"), left{}(), format{}("%c#DefaultType%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + symbol Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(SortData{}, SortData{}) : SortInt{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("#DoCompare"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1163,18,1163,62)"), left{}(), format{}("%c#DoCompare%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + symbol Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(SortMapOpInfo{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#DoMap"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1483,26,1483,42)"), left{}(), format{}("%c#DoMap%r %c(%r %1 %c)%r"), injective{}()] + symbol Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(SortTypeName{}, SortMaybeTypeName{}, SortList{}, SortList{}, SortBlock{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("110101010101"), klabel{}("#DoMap"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1631,26,1631,75)"), left{}(), format{}("%c#DoMap%r %c(%r %1 %c,%r %2 %c,%r %3 %c,%r %4 %c,%r %5 %c)%r"), injective{}()] + symbol Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(SortData{}, SortMapOpInfo{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("#DoMapAux"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1500,26,1500,51)"), left{}(), format{}("%c#DoMapAux%r %c(%r %1 %c,%r %2 %c)%r"), injective{}()] + symbol Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(SortTypeName{}, SortMaybeTypeName{}, SortList{}, SortList{}, SortBlock{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("110101010101"), klabel{}("#DoMapAux"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1632,26,1632,78)"), left{}(), format{}("%c#DoMapAux%r %c(%r %1 %c,%r %2 %c,%r %3 %c,%r %4 %c,%r %5 %c)%r"), injective{}()] + symbol Lbl'Hash'E2BIG{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#E2BIG"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2084,22,2084,54)"), left{}(), format{}("%c#E2BIG%r"), injective{}()] + symbol Lbl'Hash'EACCES{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EACCES"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2085,22,2085,56)"), left{}(), format{}("%c#EACCES%r"), injective{}()] + symbol Lbl'Hash'EADDRINUSE{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EADDRINUSE"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2134,22,2134,64)"), left{}(), format{}("%c#EADDRINUSE%r"), injective{}()] + symbol Lbl'Hash'EADDRNOTAVAIL{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EADDRNOTAVAIL"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2135,22,2135,70)"), left{}(), format{}("%c#EADDRNOTAVAIL%r"), injective{}()] + symbol Lbl'Hash'EAFNOSUPPORT{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EAFNOSUPPORT"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2133,22,2133,68)"), left{}(), format{}("%c#EAFNOSUPPORT%r"), injective{}()] + symbol Lbl'Hash'EAGAIN{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EAGAIN"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2086,22,2086,56)"), left{}(), format{}("%c#EAGAIN%r"), injective{}()] + symbol Lbl'Hash'EALREADY{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EALREADY"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2123,22,2123,60)"), left{}(), format{}("%c#EALREADY%r"), injective{}()] + symbol Lbl'Hash'EBADF{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EBADF"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2087,22,2087,54)"), left{}(), format{}("%c#EBADF%r"), injective{}()] + symbol Lbl'Hash'EBUSY{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EBUSY"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2088,22,2088,54)"), left{}(), format{}("%c#EBUSY%r"), injective{}()] + symbol Lbl'Hash'ECHILD{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ECHILD"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2089,22,2089,56)"), left{}(), format{}("%c#ECHILD%r"), injective{}()] + symbol Lbl'Hash'ECONNABORTED{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ECONNABORTED"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2139,22,2139,68)"), left{}(), format{}("%c#ECONNABORTED%r"), injective{}()] + symbol Lbl'Hash'ECONNREFUSED{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ECONNREFUSED"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2147,22,2147,68)"), left{}(), format{}("%c#ECONNREFUSED%r"), injective{}()] + symbol Lbl'Hash'ECONNRESET{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ECONNRESET"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2140,22,2140,64)"), left{}(), format{}("%c#ECONNRESET%r"), injective{}()] + symbol Lbl'Hash'EDEADLK{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EDEADLK"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2090,22,2090,58)"), left{}(), format{}("%c#EDEADLK%r"), injective{}()] + symbol Lbl'Hash'EDESTADDRREQ{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EDESTADDRREQ"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2125,22,2125,68)"), left{}(), format{}("%c#EDESTADDRREQ%r"), injective{}()] + symbol Lbl'Hash'EDOM{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EDOM"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2091,22,2091,52)"), left{}(), format{}("%c#EDOM%r"), injective{}()] + symbol Lbl'Hash'EEXIST{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EEXIST"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2092,22,2092,56)"), left{}(), format{}("%c#EEXIST%r"), injective{}()] + symbol Lbl'Hash'EFAULT{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EFAULT"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2093,22,2093,56)"), left{}(), format{}("%c#EFAULT%r"), injective{}()] + symbol Lbl'Hash'EFBIG{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EFBIG"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2094,22,2094,54)"), left{}(), format{}("%c#EFBIG%r"), injective{}()] + symbol Lbl'Hash'EHOSTDOWN{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EHOSTDOWN"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2148,22,2148,62)"), left{}(), format{}("%c#EHOSTDOWN%r"), injective{}()] + symbol Lbl'Hash'EHOSTUNREACH{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EHOSTUNREACH"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2149,22,2149,68)"), left{}(), format{}("%c#EHOSTUNREACH%r"), injective{}()] + symbol Lbl'Hash'EINPROGRESS{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EINPROGRESS"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2122,22,2122,66)"), left{}(), format{}("%c#EINPROGRESS%r"), injective{}()] + symbol Lbl'Hash'EINTR{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EINTR"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2095,22,2095,54)"), left{}(), format{}("%c#EINTR%r"), injective{}()] + symbol Lbl'Hash'EINVAL{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EINVAL"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2096,22,2096,56)"), left{}(), format{}("%c#EINVAL%r"), injective{}()] + symbol Lbl'Hash'EIO{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EIO"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2097,22,2097,50)"), left{}(), format{}("%c#EIO%r"), injective{}()] + symbol Lbl'Hash'EISCONN{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EISCONN"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2142,22,2142,58)"), left{}(), format{}("%c#EISCONN%r"), injective{}()] + symbol Lbl'Hash'EISDIR{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EISDIR"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2098,22,2098,56)"), left{}(), format{}("%c#EISDIR%r"), injective{}()] + symbol Lbl'Hash'ELOOP{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ELOOP"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2150,22,2150,54)"), left{}(), format{}("%c#ELOOP%r"), injective{}()] + symbol Lbl'Hash'EMFILE{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EMFILE"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2099,22,2099,56)"), left{}(), format{}("%c#EMFILE%r"), injective{}()] + symbol Lbl'Hash'EMLINK{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EMLINK"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2100,22,2100,56)"), left{}(), format{}("%c#EMLINK%r"), injective{}()] + symbol Lbl'Hash'EMSGSIZE{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EMSGSIZE"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2126,22,2126,60)"), left{}(), format{}("%c#EMSGSIZE%r"), injective{}()] + symbol Lbl'Hash'ENAMETOOLONG{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ENAMETOOLONG"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2101,22,2101,68)"), left{}(), format{}("%c#ENAMETOOLONG%r"), injective{}()] + symbol Lbl'Hash'ENETDOWN{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ENETDOWN"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2136,22,2136,60)"), left{}(), format{}("%c#ENETDOWN%r"), injective{}()] + symbol Lbl'Hash'ENETRESET{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ENETRESET"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2138,22,2138,62)"), left{}(), format{}("%c#ENETRESET%r"), injective{}()] + symbol Lbl'Hash'ENETUNREACH{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ENETUNREACH"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2137,22,2137,66)"), left{}(), format{}("%c#ENETUNREACH%r"), injective{}()] + symbol Lbl'Hash'ENFILE{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ENFILE"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2102,22,2102,56)"), left{}(), format{}("%c#ENFILE%r"), injective{}()] + symbol Lbl'Hash'ENOBUFS{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ENOBUFS"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2141,22,2141,58)"), left{}(), format{}("%c#ENOBUFS%r"), injective{}()] + symbol Lbl'Hash'ENODEV{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ENODEV"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2103,22,2103,56)"), left{}(), format{}("%c#ENODEV%r"), injective{}()] + symbol Lbl'Hash'ENOENT{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ENOENT"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2104,22,2104,56)"), left{}(), format{}("%c#ENOENT%r"), injective{}()] + symbol Lbl'Hash'ENOEXEC{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ENOEXEC"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2105,22,2105,58)"), left{}(), format{}("%c#ENOEXEC%r"), injective{}()] + symbol Lbl'Hash'ENOLCK{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ENOLCK"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2106,22,2106,56)"), left{}(), format{}("%c#ENOLCK%r"), injective{}()] + symbol Lbl'Hash'ENOMEM{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ENOMEM"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2107,22,2107,56)"), left{}(), format{}("%c#ENOMEM%r"), injective{}()] + symbol Lbl'Hash'ENOPROTOOPT{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ENOPROTOOPT"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2128,22,2128,66)"), left{}(), format{}("%c#ENOPROTOOPT%r"), injective{}()] + symbol Lbl'Hash'ENOSPC{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ENOSPC"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2108,22,2108,56)"), left{}(), format{}("%c#ENOSPC%r"), injective{}()] + symbol Lbl'Hash'ENOSYS{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ENOSYS"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2109,22,2109,56)"), left{}(), format{}("%c#ENOSYS%r"), injective{}()] + symbol Lbl'Hash'ENOTCONN{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ENOTCONN"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2143,22,2143,60)"), left{}(), format{}("%c#ENOTCONN%r"), injective{}()] + symbol Lbl'Hash'ENOTDIR{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ENOTDIR"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2110,22,2110,58)"), left{}(), format{}("%c#ENOTDIR%r"), injective{}()] + symbol Lbl'Hash'ENOTEMPTY{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ENOTEMPTY"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2111,22,2111,62)"), left{}(), format{}("%c#ENOTEMPTY%r"), injective{}()] + symbol Lbl'Hash'ENOTSOCK{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ENOTSOCK"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2124,22,2124,60)"), left{}(), format{}("%c#ENOTSOCK%r"), injective{}()] + symbol Lbl'Hash'ENOTTY{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ENOTTY"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2112,22,2112,56)"), left{}(), format{}("%c#ENOTTY%r"), injective{}()] + symbol Lbl'Hash'ENXIO{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ENXIO"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2113,22,2113,54)"), left{}(), format{}("%c#ENXIO%r"), injective{}()] + symbol Lbl'Hash'EOF{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EOF"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2083,22,2083,50)"), left{}(), format{}("%c#EOF%r"), injective{}()] + symbol Lbl'Hash'EOPNOTSUPP{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EOPNOTSUPP"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2131,22,2131,64)"), left{}(), format{}("%c#EOPNOTSUPP%r"), injective{}()] + symbol Lbl'Hash'EOVERFLOW{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EOVERFLOW"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2151,22,2151,62)"), left{}(), format{}("%c#EOVERFLOW%r"), injective{}()] + symbol Lbl'Hash'EPERM{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EPERM"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2114,22,2114,54)"), left{}(), format{}("%c#EPERM%r"), injective{}()] + symbol Lbl'Hash'EPFNOSUPPORT{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EPFNOSUPPORT"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2132,22,2132,68)"), left{}(), format{}("%c#EPFNOSUPPORT%r"), injective{}()] + symbol Lbl'Hash'EPIPE{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EPIPE"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2115,22,2115,54)"), left{}(), format{}("%c#EPIPE%r"), injective{}()] + symbol Lbl'Hash'EPROTONOSUPPORT{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EPROTONOSUPPORT"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2129,22,2129,74)"), left{}(), format{}("%c#EPROTONOSUPPORT%r"), injective{}()] + symbol Lbl'Hash'EPROTOTYPE{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EPROTOTYPE"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2127,22,2127,64)"), left{}(), format{}("%c#EPROTOTYPE%r"), injective{}()] + symbol Lbl'Hash'ERANGE{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ERANGE"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2116,22,2116,56)"), left{}(), format{}("%c#ERANGE%r"), injective{}()] + symbol Lbl'Hash'EROFS{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EROFS"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2117,22,2117,54)"), left{}(), format{}("%c#EROFS%r"), injective{}()] + symbol Lbl'Hash'ESHUTDOWN{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ESHUTDOWN"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2144,22,2144,62)"), left{}(), format{}("%c#ESHUTDOWN%r"), injective{}()] + symbol Lbl'Hash'ESOCKTNOSUPPORT{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ESOCKTNOSUPPORT"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2130,22,2130,74)"), left{}(), format{}("%c#ESOCKTNOSUPPORT%r"), injective{}()] + symbol Lbl'Hash'ESPIPE{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ESPIPE"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2118,22,2118,56)"), left{}(), format{}("%c#ESPIPE%r"), injective{}()] + symbol Lbl'Hash'ESRCH{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ESRCH"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2119,22,2119,54)"), left{}(), format{}("%c#ESRCH%r"), injective{}()] + symbol Lbl'Hash'ETIMEDOUT{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ETIMEDOUT"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2146,22,2146,62)"), left{}(), format{}("%c#ETIMEDOUT%r"), injective{}()] + symbol Lbl'Hash'ETOOMANYREFS{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#ETOOMANYREFS"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2145,22,2145,68)"), left{}(), format{}("%c#ETOOMANYREFS%r"), injective{}()] + symbol Lbl'Hash'EWOULDBLOCK{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EWOULDBLOCK"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2121,22,2121,66)"), left{}(), format{}("%c#EWOULDBLOCK%r"), injective{}()] + symbol Lbl'Hash'EXDEV{}() : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("#EXDEV"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2120,22,2120,54)"), left{}(), format{}("%c#EXDEV%r"), injective{}()] + symbol Lbl'Hash'ExecutePostConditions'Unds'MICHELSON'Unds'KItem{}() : SortKItem{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(613,20,613,43)"), left{}(), format{}("%c#ExecutePostConditions%r"), injective{}()] + symbol Lbl'Hash'ExecutePreConditions'Unds'MICHELSON'Unds'KItem{}() : SortKItem{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(609,20,609,42)"), left{}(), format{}("%c#ExecutePreConditions%r"), injective{}()] + symbol Lbl'Hash'ExecuteScript'Unds'MICHELSON'Unds'KItem{}() : SortKItem{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(621,20,621,35)"), left{}(), format{}("%c#ExecuteScript%r"), injective{}()] + symbol Lbl'Hash'FailureFromMutezValue'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'FailedStack'Unds'Mutez'Unds'Int'Unds'Int{}(SortMutez{}, SortInt{}, SortInt{}) : SortFailedStack{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("11010101"), klabel{}("#FailureFromMutezValue"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1837,26,1837,75)"), left{}(), format{}("%c#FailureFromMutezValue%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), function{}()] + symbol Lbl'Hash'FindSymbolsB'LParUndsRParUnds'MICHELSON'Unds'Set'Unds'Block{}(SortBlock{}) : SortSet{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#FindSymbolsB"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2154,18,2154,60)"), left{}(), format{}("%c#FindSymbolsB%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'FindSymbolsBL'LParUndsRParUnds'MICHELSON'Unds'Set'Unds'BlockList{}(SortBlockList{}) : SortSet{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#FindSymbolsBL"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2149,18,2149,65)"), left{}(), format{}("%c#FindSymbolsBL%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'FindSymbolsI'LParUndsRParUnds'MICHELSON'Unds'Set'Unds'Instruction{}(SortInstruction{}) : SortSet{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#FindSymbolsI"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2160,18,2160,66)"), left{}(), format{}("%c#FindSymbolsI%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(SortData{}, SortType{}) : SortSet{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("#FindSymbolsIn"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2171,18,2171,66)"), left{}(), format{}("%c#FindSymbolsIn%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + symbol Lbl'Hash'FindSymbolsS'LParUndsRParUnds'MICHELSON'Unds'Set'Unds'StackElementList{}(SortStackElementList{}) : SortSet{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#FindSymbolsS"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2164,18,2164,71)"), left{}(), format{}("%c#FindSymbolsS%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(SortStackElementList{}, SortStack{}) : SortKItem{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("#GeneralizeStack"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2031,20,2031,60)"), left{}(), format{}("%c#GeneralizeStack%r %c(%r %1 %c,%r %2 %c)%r"), injective{}()] + symbol Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#HandleAnnotations"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(647,26,647,59)"), left{}(), format{}("%c#HandleAnnotations%r %c(%r %1 %c)%r"), injective{}()] + hooked-symbol Lbl'Hash'ISO2Epoch'LParUndsRParUnds'MICHELSON-COMMON'Unds'Int'Unds'String{}(SortString{}) : SortInt{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#ISO2Epoch"), hook{}("TIME.ISO2Epoch"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(232,18,232,68)"), left{}(), format{}("%c#ISO2Epoch%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'Init'Unds'MICHELSON-CONFIG'Unds'KItem{}() : SortKItem{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(95,18,95,24)"), left{}(), format{}("%c#Init%r"), injective{}()] + symbol Lbl'Hash'IsComparable'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName{}(SortTypeName{}) : SortBool{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#IsComparable"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1127,19,1127,64)"), left{}(), format{}("%c#IsComparable%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'IsLegalMutezValue'LParUndsRParUnds'MICHELSON-COMMON'Unds'Bool'Unds'Int{}(SortInt{}) : SortBool{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#IsLegalMutezValue"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(147,19,147,52)"), left{}(), format{}("%c#IsLegalMutezValue%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'Key'LParUndsRParUnds'MICHELSON-COMMON'Unds'Key'Unds'String{}(SortString{}) : SortKey{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#Key"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(96,18,96,29)"), left{}(), format{}("%c#Key%r %c(%r %1 %c)%r"), injective{}()] + symbol Lbl'Hash'KeyHash'LParUndsRParUnds'MICHELSON-COMMON'Unds'KeyHash'Unds'String{}(SortString{}) : SortKeyHash{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#KeyHash"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(93,22,93,37)"), left{}(), format{}("%c#KeyHash%r %c(%r %1 %c)%r"), injective{}()] + symbol Lbl'Hash'Lambda'LParUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'LambdaData'Unds'TypeName'Unds'TypeName'Unds'Block{}(SortTypeName{}, SortTypeName{}, SortBlock{}) : SortLambdaData{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("11010101"), klabel{}("#Lambda"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(99,25,99,58)"), left{}(), format{}("%c#Lambda%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), injective{}()] + symbol Lbl'Hash'LiteralStackToStack'LParUndsRParUnds'MICHELSON-COMMON'Unds'InternalStack'Unds'OutputStack{}(SortOutputStack{}) : SortInternalStack{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#LiteralStackToStack"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(40,28,40,71)"), left{}(), format{}("%c#LiteralStackToStack%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'LiteralStackToStack'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElementList'Unds'Stack{}(SortStackElementList{}, SortStack{}) : SortStack{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("#LiteralStackToStack"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(41,20,41,75)"), left{}(), format{}("%c#LiteralStackToStack%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + symbol Lbl'Hash'LoadDefaultContractStack'Unds'MICHELSON'Unds'KItem{}() : SortKItem{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(595,20,595,46)"), left{}(), format{}("%c#LoadDefaultContractStack%r"), injective{}()] + symbol Lbl'Hash'LoadInputStack'Unds'MICHELSON'Unds'KItem{}() : SortKItem{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(574,20,574,36)"), left{}(), format{}("%c#LoadInputStack%r"), injective{}()] + hooked-symbol Lbl'Hash'MBytesLiteralToBytes'LParUndsRParUnds'MICHELSON-COMMON'Unds'Bytes'Unds'MBytesLiteral{}(SortMBytesLiteral{}) : SortBytes{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#MBytesLiteralToBytes"), hook{}("BYTES.hexstring2bytes"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(158,20,158,95)"), left{}(), format{}("%c#MBytesLiteralToBytes%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'MakeFresh'LParUndsRParUnds'MICHELSON'Unds'Data'Unds'Type{}(SortType{}) : SortData{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#MakeFresh"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2327,19,2327,34)"), left{}(), format{}("%c#MakeFresh%r %c(%r %1 %c)%r"), injective{}()] + symbol Lbl'Hash'MapOpInfo'LParUndsCommUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'MapOpInfo'Unds'TypeName'Unds'TypeName'Unds'MaybeTypeName'Unds'Map'Unds'Map'Unds'Block{}(SortTypeName{}, SortTypeName{}, SortMaybeTypeName{}, SortMap{}, SortMap{}, SortBlock{}) : SortMapOpInfo{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("11010101010101"), klabel{}("#MapOpInfo"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1476,24,1481,53)"), left{}(), format{}("%c#MapOpInfo%r %c(%r %1 %c,%r %2 %c,%r %3 %c,%r %4 %c,%r %5 %c,%r %6 %c)%r"), injective{}()] + symbol Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(SortData{}, SortData{}) : SortBool{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("#Matches"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2378,19,2378,49)"), left{}(), format{}("%c#Matches%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + symbol Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(SortDataOrSeq{}, SortType{}, SortMap{}, SortMap{}, SortGeneratedTopCell{}) : SortData{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("11010101010"), klabel{}("#MichelineToNative"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(199,19,199,74)"), left{}(), format{}("%c#MichelineToNative%r %c(%r %1 %c,%r %2 %c,%r %3 %c,%r %4 %c)%r %5"), function{}()] + symbol Lbl'Hash'MinKey'LParUndsRParUnds'MICHELSON'Unds'Data'Unds'Map{}(SortMap{}) : SortData{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#MinKey"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1509,19,1509,41)"), left{}(), format{}("%c#MinKey%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'MinimalElement'LParUndsRParUnds'MICHELSON'Unds'Data'Unds'List{}(SortList{}) : SortData{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#MinimalElement"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1374,19,1374,50)"), left{}(), format{}("%c#MinimalElement%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'MinimalElementAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Data'Unds'List'Unds'Data{}(SortList{}, SortData{}) : SortData{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("#MinimalElementAux"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1375,19,1375,59)"), left{}(), format{}("%c#MinimalElementAux%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + symbol Lbl'Hash'Mutez'LParUndsRParUnds'MICHELSON-COMMON'Unds'Mutez'Unds'Int{}(SortInt{}) : SortMutez{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#Mutez"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(92,20,92,30)"), left{}(), format{}("%c#Mutez%r %c(%r %1 %c)%r"), injective{}()] + symbol Lbl'Hash'MutezOverflowLimit'Unds'MICHELSON-COMMON'Unds'Int{}() : SortInt{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(144,18,144,49)"), left{}(), format{}("%c#MutezOverflowLimit%r"), function{}()] + symbol Lbl'Hash'Name'LParUndsRParUnds'MICHELSON-COMMON'Unds'TypeName'Unds'Type{}(SortType{}) : SortTypeName{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#Name"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(23,23,23,56)"), left{}(), format{}("%c#Name%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'NextNonce'LParUndsRParUnds'MICHELSON'Unds'OperationNonce'Unds'OperationNonce{}(SortOperationNonce{}) : SortOperationNonce{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#NextNonce"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1713,29,1713,65)"), left{}(), format{}("%c#NextNonce%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'NoData'Unds'MICHELSON-COMMON'Unds'PreData{}() : SortPreData{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(80,22,80,30)"), left{}(), format{}("%c#NoData%r"), injective{}()] + symbol Lbl'Hash'Nonce'LParUndsRParUnds'MICHELSON-COMMON'Unds'OperationNonce'Unds'Int{}(SortInt{}) : SortOperationNonce{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#Nonce"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(98,29,98,39)"), left{}(), format{}("%c#Nonce%r %c(%r %1 %c)%r"), injective{}()] + symbol Lbl'Hash'NotEq'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName'Unds'Data'Unds'Data{}(SortTypeName{}, SortData{}, SortData{}) : SortBool{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("11010101"), klabel{}("#NotEq"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1418,19,1418,69)"), left{}(), format{}("%c#NotEq%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), function{}()] + symbol Lbl'Hash'NotSet'Unds'MICHELSON-COMMON'Unds'PreType{}() : SortPreType{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(79,22,79,30)"), left{}(), format{}("%c#NotSet%r"), injective{}()] + symbol Lbl'Hash'OtherContractsMapEntryListToKMap'LParUndsRParUnds'MICHELSON-COMMON'Unds'Map'Unds'OtherContractsMapEntryList{}(SortOtherContractsMapEntryList{}) : SortMap{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#OtherContractsMapEntryListToKMap"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(186,18,186,89)"), left{}(), format{}("%c#OtherContractsMapEntryListToKMap%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'Packed'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'TypeName'Unds'Data{}(SortTypeName{}, SortData{}) : SortMBytes{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("#Packed"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(117,21,117,42)"), left{}(), format{}("%c#Packed%r %c(%r %1 %c,%r %2 %c)%r"), injective{}()] + symbol Lbl'Hash'ParseAddress'LParUndsRParUnds'MICHELSON-COMMON'Unds'Address'Unds'String{}(SortString{}) : SortAddress{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#ParseAddress"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(244,22,244,53)"), left{}(), format{}("%c#ParseAddress%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'ParseKey'LParUndsRParUnds'MICHELSON-COMMON'Unds'Key'Unds'String{}(SortString{}) : SortKey{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#ParseKey"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(247,18,247,45)"), left{}(), format{}("%c#ParseKey%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'ParseKeyHash'LParUndsRParUnds'MICHELSON-COMMON'Unds'KeyHash'Unds'String{}(SortString{}) : SortKeyHash{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#ParseKeyHash"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(241,22,241,53)"), left{}(), format{}("%c#ParseKeyHash%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'ParseSignature'LParUndsRParUnds'MICHELSON-COMMON'Unds'Signature'Unds'String{}(SortString{}) : SortSignature{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#ParseSignature"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(250,24,250,57)"), left{}(), format{}("%c#ParseSignature%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'ParseTimestamp'LParUndsRParUnds'MICHELSON-COMMON'Unds'Timestamp'Unds'String{}(SortString{}) : SortTimestamp{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#ParseTimestamp"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(233,24,233,57)"), left{}(), format{}("%c#ParseTimestamp%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(SortTypeName{}, SortData{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("#Push"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(765,26,765,45)"), left{}(), format{}("%c#Push%r %c(%r %1 %c,%r %2 %c)%r"), injective{}()] + symbol Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(SortK{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#RestoreStack"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1953,26,1953,41)"), left{}(), format{}("%c#RestoreStack%r %c(%r %1 %c)%r"), injective{}()] + symbol Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(SortMap{}) : SortKItem{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#RestoreSymbols"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2114,20,2114,39)"), left{}(), format{}("%c#RestoreSymbols%r %c(%r %1 %c)%r"), injective{}()] + symbol Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(SortStack{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#ReturnStack"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(791,26,791,44)"), left{}(), format{}("%c#ReturnStack%r %c(%r %1 %c)%r"), injective{}()] + symbol Lbl'Hash'ReverseList'LParUndsRParUnds'MICHELSON'Unds'List'Unds'List{}(SortList{}) : SortList{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#ReverseList"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1651,19,1651,47)"), left{}(), format{}("%c#ReverseList%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'ReverseListAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'List'Unds'List'Unds'List{}(SortList{}, SortList{}) : SortList{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("#ReverseListAux"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1652,19,1652,56)"), left{}(), format{}("%c#ReverseListAux%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + symbol Lbl'Hash'SHA256'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(SortMBytes{}) : SortMBytes{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#SHA256"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(119,21,119,35)"), left{}(), format{}("%c#SHA256%r %c(%r %1 %c)%r"), injective{}()] + symbol Lbl'Hash'SHA512'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(SortMBytes{}) : SortMBytes{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#SHA512"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(120,21,120,35)"), left{}(), format{}("%c#SHA512%r %c(%r %1 %c)%r"), injective{}()] + symbol Lbl'Hash'Signature'LParUndsRParUnds'MICHELSON-COMMON'Unds'Signature'Unds'String{}(SortString{}) : SortSignature{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#Signature"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(97,24,97,41)"), left{}(), format{}("%c#Signature%r %c(%r %1 %c)%r"), injective{}()] + symbol Lbl'Hash'SignedMBytes'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'MBytes'Unds'Key'Unds'Signature'Unds'MBytes{}(SortKey{}, SortSignature{}, SortMBytes{}) : SortMBytes{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("11010101"), klabel{}("#SignedMBytes"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1796,21,1796,57)"), left{}(), format{}("%c#SignedMBytes%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), injective{}()] + symbol Lbl'Hash'SliceBytes'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'OptionData'Unds'Bytes'Unds'Int'Unds'Int{}(SortBytes{}, SortInt{}, SortInt{}) : SortOptionData{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("11010101"), klabel{}("#SliceBytes"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1305,25,1305,63)"), left{}(), format{}("%c#SliceBytes%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), function{}()] + symbol Lbl'Hash'SliceString'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'OptionData'Unds'String'Unds'Int'Unds'Int{}(SortString{}, SortInt{}, SortInt{}) : SortOptionData{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("11010101"), klabel{}("#SliceString"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1245,25,1245,65)"), left{}(), format{}("%c#SliceString%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), function{}()] + symbol Lbl'Hash'StackToNative'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'InternalStack'Unds'OutputStack'Unds'Map'Unds'Map{}(SortOutputStack{}, SortMap{}, SortMap{}, SortGeneratedTopCell{}) : SortInternalStack{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("110101010"), klabel{}("#StackToNative"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(581,28,581,75)"), left{}(), format{}("%c#StackToNative%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r %4"), function{}()] + symbol Lbl'Hash'StackToNativeAux'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Stack'Unds'StackElementList'Unds'Map'Unds'Map{}(SortStackElementList{}, SortMap{}, SortMap{}, SortGeneratedTopCell{}) : SortStack{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("110101010"), klabel{}("#StackToNativeAux"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(582,20,582,75)"), left{}(), format{}("%c#StackToNativeAux%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r %4"), function{}()] + symbol Lbl'Hash'StorageTypeFromContract'LParUndsRParUnds'MICHELSON-COMMON'Unds'Type'Unds'Contract{}(SortContract{}) : SortType{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#StorageTypeFromContract"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(410,19,410,63)"), left{}(), format{}("%c#StorageTypeFromContract%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'SymbolicElement'LParUndsCommUndsRParUnds'MICHELSON'Unds'SymbolicElement'Unds'SymbolicData'Unds'Type{}(SortSymbolicData{}, SortType{}) : SortSymbolicElement{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("#SymbolicElement"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2147,30,2147,65)"), left{}(), format{}("%c#SymbolicElement%r %c(%r %1 %c,%r %2 %c)%r"), injective{}()] + symbol Lbl'Hash'Timestamp'LParUndsRParUnds'MICHELSON-COMMON'Unds'Timestamp'Unds'Int{}(SortInt{}) : SortTimestamp{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#Timestamp"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(95,24,95,38)"), left{}(), format{}("%c#Timestamp%r %c(%r %1 %c)%r"), injective{}()] + symbol Lbl'Hash'Type'LParUndsRParUnds'MICHELSON-COMMON'Unds'Type'Unds'TypeName{}(SortTypeName{}) : SortType{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#Type"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(24,19,24,56)"), left{}(), format{}("%c#Type%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'TypeFromContractStruct'LParUndsRParUnds'MICHELSON'Unds'Type'Unds'Data{}(SortData{}) : SortType{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#TypeFromContractStruct"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1736,19,1736,58)"), left{}(), format{}("%c#TypeFromContractStruct%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'TypeFromOtherContract'LParUndsRParUnds'MICHELSON-COMMON'Unds'Type'Unds'ContractData{}(SortContractData{}) : SortType{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#TypeFromOtherContract"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(422,19,422,65)"), left{}(), format{}("%c#TypeFromOtherContract%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'Typed'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'TypedData'Unds'Data'Unds'Type{}(SortData{}, SortType{}) : SortTypedData{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("#Typed"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(66,24,66,41)"), left{}(), format{}("%c#Typed%r %c(%r %1 %c,%r %2 %c)%r"), injective{}()] + symbol Lbl'Hash'TypedSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'TypedSymbol'Unds'TypeName'Unds'Data{}(SortTypeName{}, SortData{}) : SortTypedSymbol{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("#TypedSymbol"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2125,26,2125,53)"), left{}(), format{}("%c#TypedSymbol%r %c(%r %1 %c,%r %2 %c)%r"), injective{}()] + symbol Lbl'Hash'UnificationFailure'Unds'MICHELSON'Unds'UnificationFailure{}() : SortUnificationFailure{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2209,33,2209,53)"), left{}(), format{}("%c#UnificationFailure%r"), injective{}()] + symbol Lbl'Hash'UnifiedSetToList'LParUndsRParUnds'MICHELSON'Unds'UnifiedList'Unds'UnifiedSet{}(SortUnifiedSet{}) : SortUnifiedList{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#UnifiedSetToList"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2233,26,2233,77)"), left{}(), format{}("%c#UnifiedSetToList%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'UnifyTypes'LParUndsRParUnds'MICHELSON'Unds'UnifiedSet'Unds'Set{}(SortSet{}) : SortUnifiedSet{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#UnifyTypes"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2213,25,2213,63)"), left{}(), format{}("%c#UnifyTypes%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'UnknownType'Unds'MICHELSON'Unds'Type{}() : SortType{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2143,19,2143,32)"), left{}(), format{}("%c#UnknownType%r"), injective{}()] + symbol Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(SortMutez{}, SortInt{}, SortInt{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("11010101"), klabel{}("#ValidateMutezAndPush"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1826,26,1826,63)"), left{}(), format{}("%c#ValidateMutezAndPush%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), injective{}()] + hooked-symbol Lbl'Hash'accept'LParUndsRParUnds'K-IO'Unds'IOInt'Unds'Int{}(SortInt{}) : SortIOInt{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), impure{}(), hook{}("IO.accept"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2249,20,2249,80)"), left{}(), format{}("%c#accept%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'buffer'LParUndsRParUnds'K-IO'Unds'Stream'Unds'K{}(SortK{}) : SortStream{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#buffer"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2332,21,2332,30)"), left{}(), format{}("%c#buffer%r %c(%r %1 %c)%r"), injective{}()] + hooked-symbol Lbl'Hash'close'LParUndsRParUnds'K-IO'Unds'K'Unds'Int{}(SortInt{}) : SortK{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), impure{}(), hook{}("IO.close"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2223,16,2223,74)"), left{}(), format{}("%c#close%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'freezer'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}() : SortKItem{} [functional{}(), constructor{}(), priorities{}(), right{}(), terminals{}("111"), left{}(), format{}("%c#freezer#Assert(_)_MICHELSON_KItem_BoolExp0_%r %c(%r %c)%r"), injective{}()] + symbol Lbl'Hash'freezer'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}() : SortKItem{} [functional{}(), constructor{}(), priorities{}(), right{}(), terminals{}("111"), left{}(), format{}("%c#freezer#Assume(_)_MICHELSON_KItem_BoolExp0_%r %c(%r %c)%r"), injective{}()] + hooked-symbol Lbl'Hash'getc'LParUndsRParUnds'K-IO'Unds'IOInt'Unds'Int{}(SortInt{}) : SortIOInt{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), impure{}(), hook{}("IO.getc"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2204,20,2204,88)"), left{}(), format{}("%c#getc%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'hole'Unds'MICHELSON'Unds'Data{}() : SortData{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2307,21,2307,27)"), left{}(), format{}("%c#hole%r"), injective{}()] + hooked-symbol Lbl'Hash'if'UndsHash'then'UndsHash'else'UndsHash'fi'Unds'K-EQUAL-SYNTAX'Unds'Sort'Unds'Bool'Unds'Sort'Unds'Sort{SortSort}(SortBool{}, SortSort, SortSort) : SortSort [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), smt-hook{}("ite"), right{}(), terminals{}("1010101"), hook{}("KEQUAL.ite"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1967,26,1967,125)"), left{}(), format{}("%c#if%r %1 %c#then%r %2 %c#else%r %3 %c#fi%r"), function{}()] + hooked-symbol Lbl'Hash'lock'LParUndsCommUndsRParUnds'K-IO'Unds'K'Unds'Int'Unds'Int{}(SortInt{}, SortInt{}) : SortK{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("110101"), impure{}(), hook{}("IO.lock"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2235,16,2235,90)"), left{}(), format{}("%c#lock%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + hooked-symbol Lbl'Hash'logToFile{}(SortString{}, SortString{}) : SortK{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), returnsUnit{}(), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("110101"), impure{}(), klabel{}("#logToFile"), hook{}("IO.log"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2320,16,2320,120)"), left{}(), format{}("%c#logToFile%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + symbol Lbl'Hash'lookup'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'OptionData'Unds'Map'Unds'TypeName'Unds'SimpleData'Unds'TypeName{}(SortMap{}, SortTypeName{}, SortSimpleData{}, SortTypeName{}) : SortOptionData{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), smtlib{}("lookup"), terminals{}("1101010101"), klabel{}("#lookup"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1395,25,1395,95)"), left{}(), format{}("%c#lookup%r %c(%r %1 %c,%r %2 %c,%r %3 %c,%r %4 %c)%r"), function{}()] + hooked-symbol Lbl'Hash'mkstemp'LParUndsRParUnds'K-IO'Unds'IOFile'Unds'String{}(SortString{}) : SortIOFile{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), impure{}(), klabel{}("#mkstemp"), hook{}("IO.mkstemp"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2297,21,2297,83)"), left{}(), format{}("%c#mkstemp%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'open'LParUndsRParUnds'K-IO'Unds'IOInt'Unds'String{}(SortString{}) : SortIOInt{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2174,20,2174,58)"), left{}(), format{}("%c#open%r %c(%r %1 %c)%r"), function{}()] + hooked-symbol Lbl'Hash'open'LParUndsCommUndsRParUnds'K-IO'Unds'IOInt'Unds'String'Unds'String{}(SortString{}, SortString{}) : SortIOInt{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("110101"), impure{}(), hook{}("IO.open"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2175,18,2175,96)"), left{}(), format{}("%c#open%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + hooked-symbol Lbl'Hash'putc'LParUndsCommUndsRParUnds'K-IO'Unds'K'Unds'Int'Unds'Int{}(SortInt{}, SortInt{}) : SortK{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("110101"), impure{}(), hook{}("IO.putc"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2214,16,2214,92)"), left{}(), format{}("%c#putc%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + hooked-symbol Lbl'Hash'read'LParUndsCommUndsRParUnds'K-IO'Unds'IOString'Unds'Int'Unds'Int{}(SortInt{}, SortInt{}) : SortIOString{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("110101"), impure{}(), hook{}("IO.read"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2205,23,2205,98)"), left{}(), format{}("%c#read%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + hooked-symbol Lbl'Hash'remove'LParUndsRParUnds'K-IO'Unds'K'Unds'String{}(SortString{}) : SortK{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), impure{}(), klabel{}("#remove"), hook{}("IO.remove"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2308,16,2308,84)"), left{}(), format{}("%c#remove%r %c(%r %1 %c)%r"), function{}()] + hooked-symbol Lbl'Hash'seek'LParUndsCommUndsRParUnds'K-IO'Unds'K'Unds'Int'Unds'Int{}(SortInt{}, SortInt{}) : SortK{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("110101"), impure{}(), hook{}("IO.seek"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2190,16,2190,87)"), left{}(), format{}("%c#seek%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + hooked-symbol Lbl'Hash'seekEnd'LParUndsCommUndsRParUnds'K-IO'Unds'K'Unds'Int'Unds'Int{}(SortInt{}, SortInt{}) : SortK{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("110101"), impure{}(), hook{}("IO.seekEnd"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2191,16,2191,95)"), left{}(), format{}("%c#seekEnd%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + hooked-symbol Lbl'Hash'shutdownWrite'LParUndsRParUnds'K-IO'Unds'K'Unds'Int{}(SortInt{}) : SortK{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), impure{}(), hook{}("IO.shutdownWrite"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2250,16,2250,90)"), left{}(), format{}("%c#shutdownWrite%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'stderr'Unds'K-IO'Unds'Int{}() : SortInt{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2270,19,2270,50)"), left{}(), format{}("%c#stderr%r"), function{}()] + symbol Lbl'Hash'stdin'Unds'K-IO'Unds'Int{}() : SortInt{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2268,18,2268,50)"), left{}(), format{}("%c#stdin%r"), function{}()] + symbol Lbl'Hash'stdout'Unds'K-IO'Unds'Int{}() : SortInt{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2269,19,2269,50)"), left{}(), format{}("%c#stdout%r"), function{}()] + hooked-symbol Lbl'Hash'system'LParUndsRParUnds'K-IO'Unds'KItem'Unds'String{}(SortString{}) : SortKItem{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), impure{}(), klabel{}("#system"), hook{}("IO.system"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2286,20,2286,73)"), left{}(), format{}("%c#system%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'systemResult{}(SortInt{}, SortString{}, SortString{}) : SortKItem{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("11010101"), klabel{}("#systemResult"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2287,20,2287,142)"), left{}(), format{}("%c#systemResult%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), injective{}()] + hooked-symbol Lbl'Hash'tell'LParUndsRParUnds'K-IO'Unds'IOInt'Unds'Int{}(SortInt{}) : SortIOInt{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), impure{}(), hook{}("IO.tell"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2189,20,2189,76)"), left{}(), format{}("%c#tell%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'Hash'tempFile{}(SortString{}, SortInt{}) : SortIOFile{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("110101"), klabel{}("#tempFile"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2299,21,2299,92)"), left{}(), format{}("%c#tempFile%r %c(%r %1 %c,%r %2 %c)%r"), injective{}()] + hooked-symbol Lbl'Hash'time'LParRParUnds'K-IO'Unds'Int{}() : SortInt{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("111"), impure{}(), hook{}("IO.time"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2259,18,2259,66)"), left{}(), format{}("%c#time%r %c(%r %c)%r"), function{}()] + symbol Lbl'Hash'unknownIOError{}(SortInt{}) : SortIOError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1101"), klabel{}("#unknownIOError"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2083,54,2083,89)"), left{}(), format{}("%c#unknownIOError%r %c(%r %1 %c)%r"), injective{}()] + hooked-symbol Lbl'Hash'unlock'LParUndsCommUndsRParUnds'K-IO'Unds'K'Unds'Int'Unds'Int{}(SortInt{}, SortInt{}) : SortK{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("110101"), impure{}(), hook{}("IO.unlock"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2236,16,2236,94)"), left{}(), format{}("%c#unlock%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + hooked-symbol Lbl'Hash'write'LParUndsCommUndsRParUnds'K-IO'Unds'K'Unds'Int'Unds'String{}(SortInt{}, SortString{}) : SortK{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("110101"), impure{}(), hook{}("IO.write"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2215,16,2215,92)"), left{}(), format{}("%c#write%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + symbol Lbl'LPar'Failed'UndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Data{}(SortData{}) : SortFailedStack{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(549,26,549,46)"), left{}(), format{}("%c(%r %cFailed%r %1 %c)%r"), injective{}()] + symbol Lbl'LPar'GeneralOverflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(SortInt{}, SortInt{}) : SortFailedStack{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("11001"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(575,26,575,58)"), left{}(), format{}("%c(%r %cGeneralOverflow%r %1 %2 %c)%r"), injective{}()] + symbol Lbl'LPar'MutezOverflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(SortInt{}, SortInt{}) : SortFailedStack{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("11001"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(558,26,558,56)"), left{}(), format{}("%c(%r %cMutezOverflow%r %1 %2 %c)%r"), injective{}()] + symbol Lbl'LPar'MutezUnderflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(SortInt{}, SortInt{}) : SortFailedStack{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("11001"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(567,26,567,57)"), left{}(), format{}("%c(%r %cMutezUnderflow%r %1 %2 %c)%r"), injective{}()] + hooked-symbol Lbl'Stop'Bytes'Unds'BYTES-HOOKED'Unds'Bytes{}() : SortBytes{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1"), hook{}("BYTES.empty"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1615,20,1615,69)"), left{}(), format{}("%c.Bytes%r"), function{}()] + hooked-symbol Lbl'Stop'List{}() : SortList{} [latex{}("\\dotCt{List}"), functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), smtlib{}("smt_seq_nil"), terminals{}("1"), klabel{}(".List"), hook{}("LIST.unit"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(619,19,619,146)"), left{}(), format{}("%c.List%r"), function{}()] + symbol Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntryList'Unds'BigMapEntry'Unds'BigMapEntryList'QuotRBraUnds'BigMapEntryList{}() : SortBigMapEntryList{} [functional{}(), constructor{}(), userList{}("*"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), klabel{}(".List{\"BigMapEntryList\"}"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(332,30,332,77)"), left{}(), format{}("%c.BigMapEntryList%r"), injective{}()] + symbol Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OtherContractsMapEntryList'Unds'OtherContractsMapEntry'Unds'OtherContractsMapEntryList'QuotRBraUnds'OtherContractsMapEntryList{}() : SortOtherContractsMapEntryList{} [functional{}(), constructor{}(), userList{}("*"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), klabel{}(".List{\"OtherContractsMapEntryList\"}"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(324,41,324,110)"), left{}(), format{}("%c.OtherContractsMapEntryList%r"), injective{}()] + symbol Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack'QuotRBraUnds'Stack{}() : SortStack{} [functional{}(), constructor{}(), userList{}("*"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1"), klabel{}(".List{\"Stack\"}"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(37,20,37,58)"), left{}(), format{}("%c.Stack%r"), injective{}()] + symbol Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockList'Unds'Block'Unds'BlockList'QuotRBraUnds'BlockList{}() : SortBlockList{} [functional{}(), constructor{}(), userList{}("*"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), klabel{}(".List{\"BlockList\"}"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(585,24,585,59)"), left{}(), format{}("%c.BlockList%r"), injective{}()] + symbol Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'StackElementList'Unds'StackElementLiteral'Unds'StackElementList'QuotRBraUnds'StackElementList{}() : SortStackElementList{} [functional{}(), constructor{}(), userList{}("*"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), klabel{}(".List{\"StackElementList\"}"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(651,31,651,89)"), left{}(), format{}("%c.StackElementList%r"), injective{}()] + symbol Lbl'Stop'List'LBraQuotUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList'QuotRBraUnds'AnnotationList{}() : SortAnnotationList{} [functional{}(), constructor{}(), userList{}("*"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), klabel{}(".List{\"___MICHELSON-COMMON-SYNTAX\"}"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(74,29,74,48)"), left{}(), format{}("%c.AnnotationList%r"), injective{}()] + hooked-symbol Lbl'Stop'Map{}() : SortMap{} [latex{}("\\dotCt{Map}"), functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}(".Map"), hook{}("MAP.unit"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(249,18,249,128)"), left{}(), format{}("%c.Map%r"), function{}()] + hooked-symbol Lbl'Stop'Set{}() : SortSet{} [latex{}("\\dotCt{Set}"), functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}(".Set"), hook{}("SET.unit"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(499,18,499,122)"), left{}(), format{}("%c.Set%r"), function{}()] + symbol Lbl'-LT-'assumeFailed'-GT-'{}(SortBool{}) : SortAssumeFailedCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("assumeFailed"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r%i%n%1%d%n%c%r"), injective{}(), cell{}()] + symbol Lbl'-LT-'bigmaps'-GT-'{}(SortMap{}) : SortBigmapsCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("bigmaps"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r%i%n%1%d%n%c%r"), injective{}(), cell{}()] + symbol Lbl'-LT-'cutpoints'-GT-'{}(SortSet{}) : SortCutpointsCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("cutpoints"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r%i%n%1%d%n%c%r"), injective{}(), cell{}()] + symbol Lbl'-LT-'expected'-GT-'{}(SortK{}) : SortExpectedCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("expected"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r%i%n%1%d%n%c%r"), injective{}(), cell{}()] + symbol Lbl'-LT-'generatedCounter'-GT-'{}(SortInt{}) : SortGeneratedCounterCell{} [functional{}(), constructor{}(), cellName{}("generatedCounter"), priorities{}(), right{}(), terminals{}("101"), left{}(), format{}("%c%r%i%n%1%d%n%c%r"), injective{}(), cell{}()] + symbol Lbl'-LT-'generatedTop'-GT-'{}(SortMichelsonTopCell{}, SortGeneratedCounterCell{}) : SortGeneratedTopCell{} [functional{}(), constructor{}(), cellName{}("generatedTop"), priorities{}(), right{}(), terminals{}("1001"), left{}(), format{}("%1"), injective{}(), cell{}(), topcell{}()] + symbol Lbl'-LT-'generatedTop'-GT-'-fragment{}(SortMichelsonTopCellOpt{}, SortGeneratedCounterCellOpt{}) : SortGeneratedTopCellFragment{} [functional{}(), constructor{}(), cellFragment{}("GeneratedTopCell"), priorities{}(), right{}(), terminals{}("1001"), left{}(), format{}("%c-fragment%r %1 %2 %c-fragment%r"), injective{}()] + symbol Lbl'-LT-'inputstack'-GT-'{}(SortK{}) : SortInputstackCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("inputstack"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r%i%n%1%d%n%c%r"), injective{}(), cell{}()] + symbol Lbl'-LT-'invs'-GT-'{}(SortMap{}) : SortInvsCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("invs"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r%i%n%1%d%n%c%r"), injective{}(), cell{}()] + symbol Lbl'-LT-'k'-GT-'{}(SortK{}) : SortKCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("k"), maincell{}(), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r%i%n%1%d%n%c%r"), injective{}(), cell{}()] + symbol Lbl'-LT-'knownaddrs'-GT-'{}(SortMap{}) : SortKnownaddrsCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("knownaddrs"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r%i%n%1%d%n%c%r"), injective{}(), cell{}()] + symbol Lbl'-LT-'michelsonTop'-GT-'{}(SortParamtypeCell{}, SortParamvalueCell{}, SortStoragetypeCell{}, SortStoragevalueCell{}, SortMybalanceCell{}, SortMyamountCell{}, SortMynowCell{}, SortMyaddrCell{}, SortKnownaddrsCell{}, SortSourceaddrCell{}, SortSenderaddrCell{}, SortMychainidCell{}, SortNonceCell{}, SortBigmapsCell{}, SortScriptCell{}, SortKCell{}, SortStackCell{}, SortInputstackCell{}, SortExpectedCell{}, SortPreCell{}, SortPostCell{}, SortInvsCell{}, SortCutpointsCell{}, SortSymbolsCell{}, SortReturncodeCell{}, SortAssumeFailedCell{}, SortTraceCell{}) : SortMichelsonTopCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("michelsonTop"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("10000000000000000000000000001"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r%i%n%1%n%2%n%3%n%4%n%5%n%6%n%7%n%8%n%9%n%10%n%11%n%12%n%13%n%14%n%15%n%16%n%17%n%18%n%19%n%20%n%21%n%22%n%23%n%24%n%25%n%26%n%27%d%n%c%r"), injective{}(), cell{}(), topcell{}()] + symbol Lbl'-LT-'michelsonTop'-GT-'-fragment{}(SortParamtypeCellOpt{}, SortParamvalueCellOpt{}, SortStoragetypeCellOpt{}, SortStoragevalueCellOpt{}, SortMybalanceCellOpt{}, SortMyamountCellOpt{}, SortMynowCellOpt{}, SortMyaddrCellOpt{}, SortKnownaddrsCellOpt{}, SortSourceaddrCellOpt{}, SortSenderaddrCellOpt{}, SortMychainidCellOpt{}, SortNonceCellOpt{}, SortBigmapsCellOpt{}, SortScriptCellOpt{}, SortKCellOpt{}, SortStackCellOpt{}, SortInputstackCellOpt{}, SortExpectedCellOpt{}, SortPreCellOpt{}, SortPostCellOpt{}, SortInvsCellOpt{}, SortCutpointsCellOpt{}, SortSymbolsCellOpt{}, SortReturncodeCellOpt{}, SortAssumeFailedCellOpt{}, SortTraceCellOpt{}) : SortMichelsonTopCellFragment{} [functional{}(), constructor{}(), cellFragment{}("MichelsonTopCell"), priorities{}(), right{}(), terminals{}("10000000000000000000000000001"), left{}(), format{}("%c-fragment%r %1 %2 %3 %4 %5 %6 %7 %8 %9 %10 %11 %12 %13 %14 %15 %16 %17 %18 %19 %20 %21 %22 %23 %24 %25 %26 %27 %c-fragment%r"), injective{}()] + symbol Lbl'-LT-'myaddr'-GT-'{}(SortAddress{}) : SortMyaddrCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("myaddr"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r%i%n%1%d%n%c%r"), injective{}(), cell{}()] + symbol Lbl'-LT-'myamount'-GT-'{}(SortMutez{}) : SortMyamountCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("myamount"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r%i%n%1%d%n%c%r"), injective{}(), cell{}()] + symbol Lbl'-LT-'mybalance'-GT-'{}(SortMutez{}) : SortMybalanceCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("mybalance"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r%i%n%1%d%n%c%r"), injective{}(), cell{}()] + symbol Lbl'-LT-'mychainid'-GT-'{}(SortChainId{}) : SortMychainidCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("mychainid"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r%i%n%1%d%n%c%r"), injective{}(), cell{}()] + symbol Lbl'-LT-'mynow'-GT-'{}(SortTimestamp{}) : SortMynowCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("mynow"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r%i%n%1%d%n%c%r"), injective{}(), cell{}()] + symbol Lbl'-LT-'nonce'-GT-'{}(SortOperationNonce{}) : SortNonceCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("nonce"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r%i%n%1%d%n%c%r"), injective{}(), cell{}()] + symbol Lbl'-LT-'paramtype'-GT-'{}(SortPreType{}) : SortParamtypeCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("paramtype"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r%i%n%1%d%n%c%r"), injective{}(), cell{}()] + symbol Lbl'-LT-'paramvalue'-GT-'{}(SortPreData{}) : SortParamvalueCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("paramvalue"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r%i%n%1%d%n%c%r"), injective{}(), cell{}()] + symbol Lbl'-LT-'post'-GT-'{}(SortBlockList{}) : SortPostCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("post"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r%i%n%1%d%n%c%r"), injective{}(), cell{}()] + symbol Lbl'-LT-'pre'-GT-'{}(SortBlockList{}) : SortPreCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("pre"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c
%r%i%n%1%d%n%c
%r"), injective{}(), cell{}()] + symbol Lbl'-LT-'returncode'-GT-'{}(SortInt{}) : SortReturncodeCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("returncode"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r%i%n%1%d%n%c%r"), exit{}(), injective{}(), cell{}()] + symbol Lbl'-LT-'script'-GT-'{}(SortPreData{}) : SortScriptCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("script"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r"), injective{}(), cell{}()] + symbol Lbl'-LT-'senderaddr'-GT-'{}(SortAddress{}) : SortSenderaddrCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("senderaddr"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r%i%n%1%d%n%c%r"), injective{}(), cell{}()] + symbol Lbl'-LT-'sourceaddr'-GT-'{}(SortAddress{}) : SortSourceaddrCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("sourceaddr"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r%i%n%1%d%n%c%r"), injective{}(), cell{}()] + symbol Lbl'-LT-'stack'-GT-'{}(SortInternalStack{}) : SortStackCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("stack"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r%i%n%1%d%n%c%r"), injective{}(), cell{}()] + symbol Lbl'-LT-'storagetype'-GT-'{}(SortPreType{}) : SortStoragetypeCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("storagetype"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r%i%n%1%d%n%c%r"), injective{}(), cell{}()] + symbol Lbl'-LT-'storagevalue'-GT-'{}(SortPreData{}) : SortStoragevalueCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("storagevalue"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r%i%n%1%d%n%c%r"), injective{}(), cell{}()] + symbol Lbl'-LT-'symbols'-GT-'{}(SortMap{}) : SortSymbolsCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("symbols"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r%i%n%1%d%n%c%r"), injective{}(), cell{}()] + symbol Lbl'-LT-'trace'-GT-'{}(SortK{}) : SortTraceCell{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), cellName{}("trace"), priorities{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), right{}(), terminals{}("101"), contentStartLine{}("103"), contentStartColumn{}("17"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,17,360,32)"), left{}(), format{}("%c%r%i%n%1%d%n%c%r"), injective{}(), cell{}()] + symbol LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(246,26,246,45)"), left{}(), format{}("%cABS%r %1"), injective{}()] + symbol LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(281,26,281,49)"), left{}(), format{}("%cADDRESS%r %1"), injective{}()] + symbol LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(242,26,242,45)"), left{}(), format{}("%cADD%r %1"), injective{}()] + symbol LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(271,26,271,48)"), left{}(), format{}("%cAMOUNT%r %1"), injective{}()] + symbol LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(253,26,253,45)"), left{}(), format{}("%cAND%r %1"), injective{}()] + symbol LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(232,26,232,47)"), left{}(), format{}("%cAPPLY%r %1"), injective{}()] + symbol LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(SortBlockList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1930,26,1930,51)"), left{}(), format{}("%cASSERT%r %c{%r %1 %c}%r"), injective{}()] + symbol LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(SortBlockList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1931,26,1931,51)"), left{}(), format{}("%cASSUME%r %c{%r %1 %c}%r"), injective{}()] + symbol LblAborted'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Error'Unds'String'Unds'KItem'Unds'K'Unds'K{}(SortString{}, SortKItem{}, SortK{}, SortK{}) : SortError{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101010101"), klabel{}("Aborted"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(670,20,673,49)"), left{}(), format{}("%cAborted%r %c(%r %1 %c,%r %2 %c,%r %3 %c,%r %4 %c)%r"), injective{}()] + symbol LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(272,26,272,49)"), left{}(), format{}("%cBALANCE%r %1"), injective{}()] + symbol LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(SortOutputStack{}, SortBlock{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("100"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2058,26,2058,49)"), left{}(), format{}("%cBIND%r %1 %2"), injective{}()] + symbol LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(274,26,274,49)"), left{}(), format{}("%cBLAKE2B%r %1"), injective{}()] + hooked-symbol LblBase2String'LParUndsCommUndsRParUnds'STRING-COMMON'Unds'String'Unds'Int'Unds'Int{}(SortInt{}, SortInt{}) : SortString{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("Base2String"), hook{}("STRING.base2string"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1438,21,1438,98)"), left{}(), format{}("%cBase2String%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + symbol LblBig'Unds'map'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntry'Unds'Int'Unds'Type'Unds'Type'Unds'EmptyBlock{}(SortInt{}, SortType{}, SortType{}, SortEmptyBlock{}) : SortBigMapEntry{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10000"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(331,26,331,59)"), left{}(), format{}("%cBig_map%r %1 %2 %3 %4"), injective{}()] + symbol LblBig'Unds'map'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntry'Unds'Int'Unds'Type'Unds'Type'Unds'MapLiteral{}(SortInt{}, SortType{}, SortType{}, SortMapLiteral{}) : SortBigMapEntry{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10000"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(330,26,330,59)"), left{}(), format{}("%cBig_map%r %1 %2 %3 %4"), injective{}()] + symbol LblBinOpNumType'LParUndsCommUndsRParUnds'MICHELSON'Unds'NumTypeName'Unds'NumTypeName'Unds'NumTypeName{}(SortNumTypeName{}, SortNumTypeName{}) : SortNumTypeName{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("BinOpNumType"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1070,26,1070,86)"), left{}(), format{}("%cBinOpNumType%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + hooked-symbol LblBytes2Int'LParUndsCommUndsCommUndsRParUnds'BYTES-HOOKED'Unds'Int'Unds'Bytes'Unds'Endianness'Unds'Signedness{}(SortBytes{}, SortEndianness{}, SortSignedness{}) : SortInt{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("11010101"), klabel{}("Bytes2Int"), hook{}("BYTES.bytes2int"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1664,18,1664,103)"), left{}(), format{}("%cBytes2Int%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), function{}()] + hooked-symbol LblBytes2String'LParUndsRParUnds'BYTES-HOOKED'Unds'String'Unds'Bytes{}(SortBytes{}) : SortString{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("Bytes2String"), hook{}("BYTES.bytes2string"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1676,21,1676,88)"), left{}(), format{}("%cBytes2String%r %c(%r %1 %c)%r"), function{}()] + symbol LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(210,26,210,45)"), left{}(), format{}("%cCAR%r %1"), injective{}()] + symbol LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(236,26,236,46)"), left{}(), format{}("%cCAST%r %1"), injective{}()] + symbol LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(211,26,211,45)"), left{}(), format{}("%cCDR%r %1"), injective{}()] + symbol LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(270,26,270,50)"), left{}(), format{}("%cCHAIN_ID%r %1"), injective{}()] + symbol LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(273,26,273,57)"), left{}(), format{}("%cCHECK_SIGNATURE%r %1"), injective{}()] + symbol LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(256,26,256,49)"), left{}(), format{}("%cCOMPARE%r %1"), injective{}()] + symbol LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(238,26,238,48)"), left{}(), format{}("%cCONCAT%r %1"), injective{}()] + symbol LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(216,26,216,46)"), left{}(), format{}("%cCONS%r %1"), injective{}()] + symbol LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(SortAnnotationList{}, SortType{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("100"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(264,26,264,55)"), left{}(), format{}("%cCONTRACT%r %1 %2"), injective{}()] + symbol LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(267,26,267,56)"), left{}(), format{}("%cCREATE_ACCOUNT%r %1"), injective{}()] + symbol LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(SortAnnotationList{}, SortContract{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(282,26,282,74)"), left{}(), format{}("%cCREATE_CONTRACT%r %1 %c{%r %2 %c}%r"), injective{}()] + symbol LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(SortInt{}, SortInvariant{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("CUTPOINT"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2007,26,2007,65)"), left{}(), format{}("%cCUTPOINT%r %c(%r %1 %c,%r %2 %c)%r"), injective{}()] + symbol LblCreate'Unds'contract'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Contract'Unds'OptionData'Unds'Mutez'Unds'Data{}(SortInt{}, SortContract{}, SortOptionData{}, SortMutez{}, SortData{}) : SortBlockchainOperation{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("110101010101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(494,5,494,80)"), left{}(), format{}("%cCreate_contract%r %c(%r %1 %c,%r %2 %c,%r %3 %c,%r %4 %c,%r %5 %c)%r"), injective{}()] + symbol LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(SortInt{}, SortStack{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("110101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(834,26,834,57)"), left{}(), format{}("%cDIG_DOWN%r %c(%r %1 %c,%r %2 %c)%r"), injective{}()] + symbol LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(SortStack{}, SortStackElement{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("110101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(835,26,835,64)"), left{}(), format{}("%cDIG_UP%r %c(%r %1 %c,%r %2 %c)%r"), injective{}()] + symbol LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(SortAnnotationList{}, SortInt{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("100"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(199,26,199,49)"), left{}(), format{}("%cDIG%r %1 %2"), injective{}()] + symbol LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(SortAnnotationList{}, SortBlock{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("100"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(233,26,233,51)"), left{}(), format{}("%cDIP%r %1 %2"), injective{}()] + symbol LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(SortAnnotationList{}, SortInt{}, SortBlock{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1000"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(234,26,234,55)"), left{}(), format{}("%cDIP%r %1 %2 %3"), injective{}()] + symbol LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(197,26,197,46)"), left{}(), format{}("%cDROP%r %1"), injective{}()] + symbol LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(SortAnnotationList{}, SortInt{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("100"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(198,26,198,50)"), left{}(), format{}("%cDROP%r %1 %2"), injective{}()] + symbol LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(SortInt{}, SortStack{}, SortStackElement{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("11010101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(853,26,853,74)"), left{}(), format{}("%cDUG_DOWN%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), injective{}()] + symbol LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(SortK{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(854,26,854,43)"), left{}(), format{}("%cDUG_UP%r %c(%r %1 %c)%r"), injective{}()] + symbol LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(SortAnnotationList{}, SortInt{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("100"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(200,26,200,49)"), left{}(), format{}("%cDUG%r %1 %2"), injective{}()] + symbol LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(201,26,201,45)"), left{}(), format{}("%cDUP%r %1"), injective{}()] + symbol LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(245,26,245,46)"), left{}(), format{}("%cEDIV%r %1"), injective{}()] + symbol LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(SortAnnotationList{}, SortType{}, SortType{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1000"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(221,26,221,65)"), left{}(), format{}("%cEMPTY_BIG_MAP%r %1 %2 %3"), injective{}()] + symbol LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(SortAnnotationList{}, SortType{}, SortType{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1000"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(220,26,220,61)"), left{}(), format{}("%cEMPTY_MAP%r %1 %2 %3"), injective{}()] + symbol LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(SortAnnotationList{}, SortType{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("100"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(219,26,219,56)"), left{}(), format{}("%cEMPTY_SET%r %1 %2"), injective{}()] + symbol LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(257,26,257,44)"), left{}(), format{}("%cEQ%r %1"), injective{}()] + symbol LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(231,26,231,46)"), left{}(), format{}("%cEXEC%r %1"), injective{}()] + symbol LblElt'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'MapEntry'Unds'Data'Unds'Data{}(SortData{}, SortData{}) : SortMapEntry{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("100"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(52,23,52,37)"), left{}(), format{}("%cElt%r %1 %2"), injective{}()] + symbol LblElt'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OtherContractsMapEntry'Unds'String'Unds'Type{}(SortString{}, SortType{}) : SortOtherContractsMapEntry{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("100"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(323,37,323,53)"), left{}(), format{}("%cElt%r %1 %2"), injective{}()] + symbol LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(235,26,235,50)"), left{}(), format{}("%cFAILWITH%r %1"), injective{}()] + hooked-symbol LblFloat2String'LParUndsRParUnds'STRING-COMMON'Unds'String'Unds'Float{}(SortFloat{}) : SortString{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("Float2String"), hook{}("STRING.float2string"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1415,21,1415,105)"), left{}(), format{}("%cFloat2String%r %c(%r %1 %c)%r"), function{}()] + hooked-symbol LblFloat2String'LParUndsCommUndsRParUnds'STRING-COMMON'Unds'String'Unds'Float'Unds'String{}(SortFloat{}, SortString{}) : SortString{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("FloatFormat"), hook{}("STRING.floatFormat"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1416,21,1416,121)"), left{}(), format{}("%cFloat2String%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + symbol LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(225,26,225,45)"), left{}(), format{}("%cGET%r %1"), injective{}()] + symbol LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(262,26,262,44)"), left{}(), format{}("%cGE%r %1"), injective{}()] + symbol LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(260,26,260,44)"), left{}(), format{}("%cGT%r %1"), injective{}()] + symbol LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(277,26,277,50)"), left{}(), format{}("%cHASH_KEY%r %1"), injective{}()] + symbol LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(SortAnnotationList{}, SortBlock{}, SortBlock{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1000"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(217,26,217,61)"), left{}(), format{}("%cIF_CONS%r %1 %2 %3"), injective{}()] + symbol LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(SortAnnotationList{}, SortBlock{}, SortBlock{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1000"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(214,26,214,61)"), left{}(), format{}("%cIF_LEFT%r %1 %2 %3"), injective{}()] + symbol LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(SortAnnotationList{}, SortBlock{}, SortBlock{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1000"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(207,26,207,61)"), left{}(), format{}("%cIF_NONE%r %1 %2 %3"), injective{}()] + symbol LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(SortAnnotationList{}, SortBlock{}, SortBlock{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1000"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(227,26,227,56)"), left{}(), format{}("%cIF%r %1 %2 %3"), injective{}()] + symbol LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(268,26,268,58)"), left{}(), format{}("%cIMPLICIT_ACCOUNT%r %1"), injective{}()] + symbol LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(248,26,248,45)"), left{}(), format{}("%cINT%r %1"), injective{}()] + symbol LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(247,26,247,47)"), left{}(), format{}("%cISNAT%r %1"), injective{}()] + symbol LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(SortAnnotationList{}, SortBlock{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("100"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(223,26,223,52)"), left{}(), format{}("%cITER%r %1 %2"), injective{}()] + hooked-symbol LblId2String'LParUndsRParUnds'ID-COMMON'Unds'String'Unds'Id{}(SortId{}) : SortString{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("Id2String"), hook{}("STRING.token2string"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1923,21,1923,89)"), left{}(), format{}("%cId2String%r %c(%r %1 %c)%r"), function{}()] + symbol LblInt2Bytes'LParUndsCommUndsCommUndsRParUnds'BYTES-HOOKED'Unds'Bytes'Unds'Int'Unds'Endianness'Unds'Signedness{}(SortInt{}, SortEndianness{}, SortSignedness{}) : SortBytes{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("11010101"), klabel{}("Int2BytesNoLen"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1666,20,1666,104)"), left{}(), format{}("%cInt2Bytes%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), function{}()] + hooked-symbol LblInt2Bytes'LParUndsCommUndsCommUndsRParUnds'BYTES-HOOKED'Unds'Bytes'Unds'Int'Unds'Int'Unds'Endianness{}(SortInt{}, SortInt{}, SortEndianness{}) : SortBytes{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("11010101"), klabel{}("Int2Bytes"), hook{}("BYTES.int2bytes"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1665,20,1665,104)"), left{}(), format{}("%cInt2Bytes%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), function{}()] + hooked-symbol LblInt2String'LParUndsRParUnds'STRING-COMMON'Unds'String'Unds'Int{}(SortInt{}) : SortString{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("Int2String"), hook{}("STRING.int2string"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1437,21,1437,103)"), left{}(), format{}("%cInt2String%r %c(%r %1 %c)%r"), function{}()] + symbol LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(SortAnnotationList{}, SortType{}, SortType{}, SortBlock{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10000"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(230,26,230,64)"), left{}(), format{}("%cLAMBDA%r %1 %2 %3 %4"), injective{}()] + symbol LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(SortAnnotationList{}, SortType{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("100"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(212,26,212,51)"), left{}(), format{}("%cLEFT%r %1 %2"), injective{}()] + symbol LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(261,26,261,44)"), left{}(), format{}("%cLE%r %1"), injective{}()] + symbol LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(SortAnnotationList{}, SortBlock{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("100"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(229,26,229,57)"), left{}(), format{}("%cLOOP_LEFT%r %1 %2"), injective{}()] + symbol LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(SortAnnotationList{}, SortBlock{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("100"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(228,26,228,52)"), left{}(), format{}("%cLOOP%r %1 %2"), injective{}()] + symbol LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(250,26,250,45)"), left{}(), format{}("%cLSL%r %1"), injective{}()] + symbol LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(251,26,251,45)"), left{}(), format{}("%cLSR%r %1"), injective{}()] + symbol LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(259,26,259,44)"), left{}(), format{}("%cLT%r %1"), injective{}()] + symbol LblLeft'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(SortData{}) : SortOrData{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(99,21,99,31)"), left{}(), format{}("%cLeft%r %1"), injective{}()] + hooked-symbol LblList2Set'LParUndsRParUnds'COLLECTIONS'Unds'Set'Unds'List{}(SortList{}) : SortSet{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("List2Set"), hook{}("SET.list2set"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(732,18,732,74)"), left{}(), format{}("%cList2Set%r %c(%r %1 %c)%r"), function{}()] + hooked-symbol LblList'Coln'get{}(SortList{}, SortInt{}) : SortKItem{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("0101"), klabel{}("List:get"), hook{}("LIST.get"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(638,20,638,98)"), left{}(), format{}("%1 %c[%r %2 %c]%r"), function{}()] + hooked-symbol LblList'Coln'range{}(SortList{}, SortInt{}, SortInt{}) : SortList{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("11010101"), klabel{}("List:range"), hook{}("LIST.range"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(685,19,685,119)"), left{}(), format{}("%crange%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), function{}()] + hooked-symbol LblListItem{}(SortKItem{}) : SortList{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), smtlib{}("smt_seq_elem"), terminals{}("1101"), klabel{}("ListItem"), hook{}("LIST.element"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(627,19,627,136)"), left{}(), format{}("%cListItem%r %c(%r %1 %c)%r"), function{}()] + symbol LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(SortAnnotationList{}, SortBlock{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("100"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(222,26,222,51)"), left{}(), format{}("%cMAP%r %1 %2"), injective{}()] + symbol LblMBytesLiteral{}(SortMBytesLiteral{}) : SortMBytes{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("0"), klabel{}("MBytesLiteral"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(81,21,81,82)"), left{}(), format{}("%1"), avoid{}(), function{}()] + symbol LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(224,26,224,45)"), left{}(), format{}("%cMEM%r %1"), injective{}()] + symbol LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(244,26,244,45)"), left{}(), format{}("%cMUL%r %1"), injective{}()] + hooked-symbol LblMap'Coln'lookup{}(SortMap{}, SortKItem{}) : SortKItem{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("0101"), klabel{}("Map:lookup"), hook{}("MAP.lookup"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(272,20,272,112)"), left{}(), format{}("%1 %c[%r %2 %c]%r"), function{}()] + hooked-symbol LblMap'Coln'update{}(SortMap{}, SortKItem{}, SortKItem{}) : SortMap{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), prefer{}(), right{}(), terminals{}("010101"), klabel{}("Map:update"), hook{}("MAP.update"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(291,18,291,144)"), left{}(), format{}("%1 %c[%r %2 %c<-%r %3 %c]%r"), function{}()] + symbol LblMichelsonBool{}(SortMichelsonBool{}) : SortData{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("0"), klabel{}("MichelsonBool"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(88,19,88,80)"), left{}(), format{}("%1"), avoid{}(), function{}()] + symbol LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(249,26,249,45)"), left{}(), format{}("%cNEG%r %1"), injective{}()] + symbol LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(258,26,258,45)"), left{}(), format{}("%cNEQ%r %1"), injective{}()] + symbol LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(SortAnnotationList{}, SortType{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("100"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(215,26,215,50)"), left{}(), format{}("%cNIL%r %1 %2"), injective{}()] + symbol LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(SortAnnotationList{}, SortType{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("100"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(205,26,205,51)"), left{}(), format{}("%cNONE%r %1 %2"), injective{}()] + symbol LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(255,26,255,45)"), left{}(), format{}("%cNOT%r %1"), injective{}()] + symbol LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(269,26,269,45)"), left{}(), format{}("%cNOW%r %1"), injective{}()] + symbol LblNoneType'Unds'MICHELSON'Unds'MaybeTypeName{}() : SortMaybeTypeName{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1518,28,1518,37)"), left{}(), format{}("%cNoneType%r"), injective{}()] + symbol LblNone'Unds'MICHELSON-COMMON-SYNTAX'Unds'OptionData{}() : SortOptionData{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(103,25,103,30)"), left{}(), format{}("%cNone%r"), injective{}()] + symbol LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(252,26,252,44)"), left{}(), format{}("%cOR%r %1"), injective{}()] + symbol LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(240,26,240,46)"), left{}(), format{}("%cPACK%r %1"), injective{}()] + symbol LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(208,26,208,46)"), left{}(), format{}("%cPAIR%r %1"), injective{}()] + symbol LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(SortString{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("PAUSE"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(291,26,291,38)"), left{}(), format{}("%cPAUSE%r %c(%r %1 %c)%r"), injective{}()] + symbol LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}() : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(290,26,290,32)"), left{}(), format{}("%cPAUSE%r"), injective{}()] + symbol LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(SortAnnotationList{}, SortType{}, SortData{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1000"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(203,26,203,56)"), left{}(), format{}("%cPUSH%r %1 %2 %3"), injective{}()] + symbol LblPair'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Pair'Unds'Data'Unds'Data{}(SortData{}, SortData{}) : SortPair{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("100"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(97,19,97,34)"), left{}(), format{}("%cPair%r %1 %2"), injective{}()] + symbol LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(237,26,237,48)"), left{}(), format{}("%cRENAME%r %1"), injective{}()] + symbol LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(SortAnnotationList{}, SortType{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("100"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(213,26,213,52)"), left{}(), format{}("%cRIGHT%r %1 %2"), injective{}()] + symbol LblRight'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(SortData{}) : SortOrData{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(100,21,100,32)"), left{}(), format{}("%cRight%r %1"), injective{}()] + symbol LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(263,26,263,46)"), left{}(), format{}("%cSELF%r %1"), injective{}()] + symbol LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(280,26,280,48)"), left{}(), format{}("%cSENDER%r %1"), injective{}()] + symbol LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(266,26,266,54)"), left{}(), format{}("%cSET_DELEGATE%r %1"), injective{}()] + symbol LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(275,26,275,48)"), left{}(), format{}("%cSHA256%r %1"), injective{}()] + symbol LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(276,26,276,48)"), left{}(), format{}("%cSHA512%r %1"), injective{}()] + symbol LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(218,26,218,46)"), left{}(), format{}("%cSIZE%r %1"), injective{}()] + symbol LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(239,26,239,47)"), left{}(), format{}("%cSLICE%r %1"), injective{}()] + symbol LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(204,26,204,46)"), left{}(), format{}("%cSOME%r %1"), injective{}()] + symbol LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(279,26,279,48)"), left{}(), format{}("%cSOURCE%r %1"), injective{}()] + symbol LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(278,26,278,56)"), left{}(), format{}("%cSTEPS_TO_QUOTA%r %1"), injective{}()] + symbol LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}() : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(289,26,289,31)"), left{}(), format{}("%cSTOP%r"), injective{}()] + symbol LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(243,26,243,45)"), left{}(), format{}("%cSUB%r %1"), injective{}()] + symbol LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(202,26,202,46)"), left{}(), format{}("%cSWAP%r %1"), injective{}()] + hooked-symbol LblSet2List'LParUndsRParUnds'COLLECTIONS'Unds'List'Unds'Set{}(SortSet{}) : SortList{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("Set2List"), hook{}("SET.set2list"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(731,19,731,74)"), left{}(), format{}("%cSet2List%r %c(%r %1 %c)%r"), function{}()] + hooked-symbol LblSet'Coln'difference{}(SortSet{}, SortSet{}) : SortSet{} [latex{}("{#1}-_{\\it Set}{#2}"), functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("010"), klabel{}("Set:difference"), hook{}("SET.difference"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(539,18,539,146)"), left{}(), format{}("%1 %c-Set%r %2"), function{}()] + hooked-symbol LblSet'Coln'in{}(SortKItem{}, SortSet{}) : SortBool{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("010"), klabel{}("Set:in"), hook{}("SET.in"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(547,19,547,106)"), left{}(), format{}("%1 %cin%r %2"), function{}()] + hooked-symbol LblSetItem{}(SortKItem{}) : SortSet{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1101"), klabel{}("SetItem"), hook{}("SET.element"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(507,18,507,112)"), left{}(), format{}("%cSetItem%r %c(%r %1 %c)%r"), function{}()] + symbol LblSet'Unds'delegate'LParUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'OptionData{}(SortInt{}, SortOptionData{}) : SortBlockchainOperation{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("110101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(525,34,525,74)"), left{}(), format{}("%cSet_delegate%r %c(%r %1 %c,%r %2 %c)%r"), injective{}()] + symbol LblSome'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OptionData'Unds'Data{}(SortData{}) : SortOptionData{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(102,25,102,35)"), left{}(), format{}("%cSome%r %1"), injective{}()] + symbol LblStack'Unds'elt'UndsUndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'StackElementLiteral'Unds'Type'Unds'Data{}(SortType{}, SortData{}) : SortStackElementLiteral{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("100"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(650,34,650,54)"), left{}(), format{}("%cStack_elt%r %1 %2"), injective{}()] + hooked-symbol LblString2Base'LParUndsCommUndsRParUnds'STRING-COMMON'Unds'Int'Unds'String'Unds'Int{}(SortString{}, SortInt{}) : SortInt{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("String2Base"), hook{}("STRING.string2base"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1439,21,1439,98)"), left{}(), format{}("%cString2Base%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + hooked-symbol LblString2Bytes'LParUndsRParUnds'BYTES-HOOKED'Unds'Bytes'Unds'String{}(SortString{}) : SortBytes{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("String2Bytes"), hook{}("BYTES.string2bytes"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1677,20,1677,88)"), left{}(), format{}("%cString2Bytes%r %c(%r %1 %c)%r"), function{}()] + hooked-symbol LblString2Float'LParUndsRParUnds'STRING-COMMON'Unds'Float'Unds'String{}(SortString{}) : SortFloat{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("String2Float"), hook{}("STRING.string2float"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1417,21,1417,93)"), left{}(), format{}("%cString2Float%r %c(%r %1 %c)%r"), function{}()] + hooked-symbol LblString2Id'LParUndsRParUnds'ID-COMMON'Unds'Id'Unds'String{}(SortString{}) : SortId{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("String2Id"), hook{}("STRING.string2token"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1924,17,1924,84)"), left{}(), format{}("%cString2Id%r %c(%r %1 %c)%r"), function{}()] + hooked-symbol LblString2Int'LParUndsRParUnds'STRING-COMMON'Unds'Int'Unds'String{}(SortString{}) : SortInt{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("String2Int"), hook{}("STRING.string2int"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1436,21,1436,91)"), left{}(), format{}("%cString2Int%r %c(%r %1 %c)%r"), function{}()] + symbol LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(SortString{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("TRACE"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(292,26,292,38)"), left{}(), format{}("%cTRACE%r %c(%r %1 %c)%r"), injective{}()] + symbol LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(265,26,265,57)"), left{}(), format{}("%cTRANSFER_TOKENS%r %1"), injective{}()] + symbol LblTransfer'Unds'tokens'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Data'Unds'Mutez'Unds'Address{}(SortInt{}, SortData{}, SortMutez{}, SortAddress{}) : SortBlockchainOperation{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1101010101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(512,5,512,64)"), left{}(), format{}("%cTransfer_tokens%r %c(%r %1 %c,%r %2 %c,%r %3 %c,%r %4 %c)%r"), injective{}()] + symbol LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(206,26,206,46)"), left{}(), format{}("%cUNIT%r %1"), injective{}()] + symbol LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(SortAnnotationList{}, SortType{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("100"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(241,26,241,53)"), left{}(), format{}("%cUNPACK%r %1 %2"), injective{}()] + symbol LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(209,26,209,48)"), left{}(), format{}("%cUNPAIR%r %1"), injective{}()] + symbol LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(226,26,226,48)"), left{}(), format{}("%cUPDATE%r %1"), injective{}()] + symbol LblUnit'Unds'MICHELSON-COMMON-SYNTAX'Unds'SimpleData{}() : SortSimpleData{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(126,25,126,30)"), left{}(), format{}("%cUnit%r"), injective{}()] + symbol LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(SortAnnotationList{}) : SortInstruction{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(254,26,254,45)"), left{}(), format{}("%cXOR%r %1"), injective{}()] + symbol Lbl'LSqBUndsUndsRSqBUnds'MICHELSON-COMMON'Unds'StackElement'Unds'TypeName'Unds'Data{}(SortTypeName{}, SortData{}) : SortStackElement{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1001"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(36,27,36,47)"), left{}(), format{}("%c[%r %1 %2 %c]%r"), injective{}()] + hooked-symbol Lbl'UndsPerc'Int'Unds'{}(SortInt{}, SortInt{}) : SortInt{} [latex{}("{#1}\\mathrel{\\%_{\\scriptstyle\\it Int}}{#2}"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(Lbl'UndsPlus'Int'Unds'{}(),Lbl'Unds-GT--GT-'Int'Unds'{}(),Lbl'Unds'xorInt'Unds'{}(),Lbl'UndsAnd-'Int'Unds'{}(),Lbl'Unds-LT--LT-'Int'Unds'{}(),Lbl'UndsPipe'Int'Unds'{}(),Lbl'Unds'-Int'Unds'{}()), smt-hook{}("mod"), right{}(), terminals{}("010"), klabel{}("_%Int_"), hook{}("INT.tmod"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(896,18,896,170)"), left{}(Lbl'UndsStar'Int'Unds'{}(),Lbl'Unds'divInt'Unds'{}(),Lbl'UndsPerc'Int'Unds'{}(),Lbl'UndsSlsh'Int'Unds'{}(),Lbl'Unds'modInt'Unds'{}()), format{}("%1 %c%%Int%r %2"), function{}()] + hooked-symbol Lbl'UndsAnd-'Int'Unds'{}(SortInt{}, SortInt{}) : SortInt{} [latex{}("{#1}\\mathrel{\\&_{\\scriptstyle\\it Int}}{#2}"), functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(Lbl'Unds'xorInt'Unds'{}(),Lbl'UndsPipe'Int'Unds'{}()), right{}(), smtlib{}("andInt"), terminals{}("010"), klabel{}("_&Int_"), hook{}("INT.and"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(907,18,907,182)"), left{}(Lbl'UndsAnd-'Int'Unds'{}()), format{}("%1 %c&Int%r %2"), function{}()] + hooked-symbol Lbl'UndsStar'Int'Unds'{}(SortInt{}, SortInt{}) : SortInt{} [latex{}("{#1}\\mathrel{\\ast_{\\scriptstyle\\it Int}}{#2}"), functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(Lbl'UndsPlus'Int'Unds'{}(),Lbl'Unds-GT--GT-'Int'Unds'{}(),Lbl'Unds'xorInt'Unds'{}(),Lbl'UndsAnd-'Int'Unds'{}(),Lbl'Unds-LT--LT-'Int'Unds'{}(),Lbl'UndsPipe'Int'Unds'{}(),Lbl'Unds'-Int'Unds'{}()), smt-hook{}("*"), right{}(), terminals{}("010"), klabel{}("_*Int_"), hook{}("INT.mul"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(892,18,892,181)"), left{}(Lbl'Unds'modInt'Unds'{}(),Lbl'UndsPerc'Int'Unds'{}(),Lbl'UndsSlsh'Int'Unds'{}(),Lbl'Unds'divInt'Unds'{}(),Lbl'UndsStar'Int'Unds'{}()), format{}("%1 %c*Int%r %2"), function{}()] + hooked-symbol Lbl'UndsPlus'Bytes'UndsUnds'BYTES-HOOKED'Unds'Bytes'Unds'Bytes'Unds'Bytes{}(SortBytes{}, SortBytes{}) : SortBytes{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(Lbl'UndsPlus'Bytes'UndsUnds'BYTES-HOOKED'Unds'Bytes'Unds'Bytes'Unds'Bytes{}()), terminals{}("010"), hook{}("BYTES.concat"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1762,20,1762,89)"), left{}(), format{}("%1 %c+Bytes%r %2"), function{}()] + hooked-symbol Lbl'UndsPlus'Int'Unds'{}(SortInt{}, SortInt{}) : SortInt{} [latex{}("{#1}\\mathrel{+_{\\scriptstyle\\it Int}}{#2}"), functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(Lbl'Unds-GT--GT-'Int'Unds'{}(),Lbl'Unds'xorInt'Unds'{}(),Lbl'UndsAnd-'Int'Unds'{}(),Lbl'Unds-LT--LT-'Int'Unds'{}(),Lbl'UndsPipe'Int'Unds'{}()), smt-hook{}("+"), right{}(), terminals{}("010"), klabel{}("_+Int_"), hook{}("INT.add"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(901,18,901,178)"), left{}(Lbl'UndsPlus'Int'Unds'{}(),Lbl'Unds'-Int'Unds'{}()), format{}("%1 %c+Int%r %2"), function{}()] + hooked-symbol Lbl'UndsPlus'String'UndsUnds'STRING-COMMON'Unds'String'Unds'String'Unds'String{}(SortString{}, SortString{}) : SortString{} [latex{}("{#1}+_{\\scriptstyle\\it String}{#2}"), functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("010"), hook{}("STRING.concat"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1347,21,1347,139)"), left{}(Lbl'UndsPlus'String'UndsUnds'STRING-COMMON'Unds'String'Unds'String'Unds'String{}()), format{}("%1 %c+String%r %2"), function{}()] + hooked-symbol Lbl'Unds'-Int'Unds'{}(SortInt{}, SortInt{}) : SortInt{} [latex{}("{#1}\\mathrel{-_{\\scriptstyle\\it Int}}{#2}"), functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(Lbl'Unds-GT--GT-'Int'Unds'{}(),Lbl'Unds'xorInt'Unds'{}(),Lbl'UndsAnd-'Int'Unds'{}(),Lbl'Unds-LT--LT-'Int'Unds'{}(),Lbl'UndsPipe'Int'Unds'{}()), smt-hook{}("-"), right{}(), terminals{}("010"), klabel{}("_-Int_"), hook{}("INT.sub"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(902,18,902,178)"), left{}(Lbl'UndsPlus'Int'Unds'{}(),Lbl'Unds'-Int'Unds'{}()), format{}("%1 %c-Int%r %2"), function{}()] + hooked-symbol Lbl'Unds'-Map'UndsUnds'MAP'Unds'Map'Unds'Map'Unds'Map{}(SortMap{}, SortMap{}) : SortMap{} [latex{}("{#1}-_{\\it Map}{#2}"), functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("010"), hook{}("MAP.difference"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(312,18,312,120)"), left{}(), format{}("%1 %c-Map%r %2"), function{}()] + hooked-symbol Lbl'UndsSlsh'Int'Unds'{}(SortInt{}, SortInt{}) : SortInt{} [latex{}("{#1}\\mathrel{\\div_{\\scriptstyle\\it Int}}{#2}"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(Lbl'UndsPlus'Int'Unds'{}(),Lbl'Unds-GT--GT-'Int'Unds'{}(),Lbl'Unds'xorInt'Unds'{}(),Lbl'UndsAnd-'Int'Unds'{}(),Lbl'Unds-LT--LT-'Int'Unds'{}(),Lbl'UndsPipe'Int'Unds'{}(),Lbl'Unds'-Int'Unds'{}()), smt-hook{}("div"), right{}(), terminals{}("010"), klabel{}("_/Int_"), hook{}("INT.tdiv"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(895,18,895,172)"), left{}(Lbl'UndsSlsh'Int'Unds'{}(),Lbl'Unds'modInt'Unds'{}(),Lbl'Unds'divInt'Unds'{}(),Lbl'UndsPerc'Int'Unds'{}(),Lbl'UndsStar'Int'Unds'{}()), format{}("%1 %c/Int%r %2"), function{}()] + symbol Lbl'UndsSClnUndsSClnUndsSClnUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'CodeDecl'Unds'ParameterDecl'Unds'StorageDecl{}(SortCodeDecl{}, SortParameterDecl{}, SortStorageDecl{}) : SortContract{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), anywhere{}(), priorities{}(), right{}(), terminals{}("010101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(304,23,304,68)"), left{}(), format{}("%1 %c;%r %2 %c;%r %3 %c;%r"), injective{}()] + symbol Lbl'UndsSClnUndsSClnUndsSClnUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'CodeDecl'Unds'StorageDecl'Unds'ParameterDecl{}(SortCodeDecl{}, SortStorageDecl{}, SortParameterDecl{}) : SortContract{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("010101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(303,23,303,68)"), left{}(), format{}("%1 %c;%r %2 %c;%r %3 %c;%r"), injective{}()] + symbol Lbl'UndsSClnUndsSClnUndsSClnUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'ParameterDecl'Unds'CodeDecl'Unds'StorageDecl{}(SortParameterDecl{}, SortCodeDecl{}, SortStorageDecl{}) : SortContract{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), anywhere{}(), priorities{}(), right{}(), terminals{}("010101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(306,23,306,68)"), left{}(), format{}("%1 %c;%r %2 %c;%r %3 %c;%r"), injective{}()] + symbol Lbl'UndsSClnUndsSClnUndsSClnUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'ParameterDecl'Unds'StorageDecl'Unds'CodeDecl{}(SortParameterDecl{}, SortStorageDecl{}, SortCodeDecl{}) : SortContract{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), anywhere{}(), priorities{}(), right{}(), terminals{}("010101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(308,23,308,68)"), left{}(), format{}("%1 %c;%r %2 %c;%r %3 %c;%r"), injective{}()] + symbol Lbl'UndsSClnUndsSClnUndsSClnUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'StorageDecl'Unds'CodeDecl'Unds'ParameterDecl{}(SortStorageDecl{}, SortCodeDecl{}, SortParameterDecl{}) : SortContract{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), anywhere{}(), priorities{}(), right{}(), terminals{}("010101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(305,23,305,68)"), left{}(), format{}("%1 %c;%r %2 %c;%r %3 %c;%r"), injective{}()] + symbol Lbl'UndsSClnUndsSClnUndsSClnUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'StorageDecl'Unds'ParameterDecl'Unds'CodeDecl{}(SortStorageDecl{}, SortParameterDecl{}, SortCodeDecl{}) : SortContract{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), anywhere{}(), priorities{}(), right{}(), terminals{}("010101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(307,23,307,68)"), left{}(), format{}("%1 %c;%r %2 %c;%r %3 %c;%r"), injective{}()] + symbol Lbl'UndsSClnUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'CodeDecl'Unds'ParameterDecl'Unds'StorageDecl{}(SortCodeDecl{}, SortParameterDecl{}, SortStorageDecl{}) : SortContract{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), anywhere{}(), priorities{}(), right{}(), terminals{}("01010"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(311,23,311,64)"), left{}(), format{}("%1 %c;%r %2 %c;%r %3"), injective{}()] + symbol Lbl'UndsSClnUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'CodeDecl'Unds'StorageDecl'Unds'ParameterDecl{}(SortCodeDecl{}, SortStorageDecl{}, SortParameterDecl{}) : SortContract{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), anywhere{}(), priorities{}(), right{}(), terminals{}("01010"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(310,23,310,64)"), left{}(), format{}("%1 %c;%r %2 %c;%r %3"), injective{}()] + symbol Lbl'UndsSClnUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'ParameterDecl'Unds'CodeDecl'Unds'StorageDecl{}(SortParameterDecl{}, SortCodeDecl{}, SortStorageDecl{}) : SortContract{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), anywhere{}(), priorities{}(), right{}(), terminals{}("01010"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(313,23,313,64)"), left{}(), format{}("%1 %c;%r %2 %c;%r %3"), injective{}()] + symbol Lbl'UndsSClnUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'ParameterDecl'Unds'StorageDecl'Unds'CodeDecl{}(SortParameterDecl{}, SortStorageDecl{}, SortCodeDecl{}) : SortContract{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), anywhere{}(), priorities{}(), right{}(), terminals{}("01010"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(315,23,315,64)"), left{}(), format{}("%1 %c;%r %2 %c;%r %3"), injective{}()] + symbol Lbl'UndsSClnUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'StorageDecl'Unds'CodeDecl'Unds'ParameterDecl{}(SortStorageDecl{}, SortCodeDecl{}, SortParameterDecl{}) : SortContract{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), anywhere{}(), priorities{}(), right{}(), terminals{}("01010"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(312,23,312,64)"), left{}(), format{}("%1 %c;%r %2 %c;%r %3"), injective{}()] + symbol Lbl'UndsSClnUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'StorageDecl'Unds'ParameterDecl'Unds'CodeDecl{}(SortStorageDecl{}, SortParameterDecl{}, SortCodeDecl{}) : SortContract{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), anywhere{}(), priorities{}(), right{}(), terminals{}("01010"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(314,23,314,64)"), left{}(), format{}("%1 %c;%r %2 %c;%r %3"), injective{}()] + symbol Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntryList'Unds'BigMapEntry'Unds'BigMapEntryList{}(SortBigMapEntry{}, SortBigMapEntryList{}) : SortBigMapEntryList{} [functional{}(), constructor{}(), userList{}("*"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("010"), klabel{}("BigMapEntryList"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(332,30,332,77)"), left{}(), format{}("%1 %c;%r %2"), injective{}()] + symbol Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'DataList'Unds'Data'Unds'DataList{}(SortData{}, SortDataList{}) : SortDataList{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("010"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(59,30,59,46)"), left{}(), format{}("%1 %c;%r %2"), injective{}()] + symbol Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Groups'Unds'Group'Unds'Groups{}(SortGroup{}, SortGroups{}) : SortGroups{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("010"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(381,21,381,36)"), left{}(), format{}("%1 %c;%r %2"), injective{}()] + symbol Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'MapEntryList'Unds'MapEntry'Unds'MapEntryList{}(SortMapEntry{}, SortMapEntryList{}) : SortMapEntryList{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("010"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(61,38,61,62)"), left{}(), format{}("%1 %c;%r %2"), injective{}()] + symbol Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OtherContractsMapEntryList'Unds'OtherContractsMapEntry'Unds'OtherContractsMapEntryList{}(SortOtherContractsMapEntry{}, SortOtherContractsMapEntryList{}) : SortOtherContractsMapEntryList{} [functional{}(), constructor{}(), userList{}("*"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("010"), klabel{}("OtherContractsMapEntryList"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(324,41,324,110)"), left{}(), format{}("%1 %c;%r %2"), injective{}()] + symbol Lbl'UndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack{}(SortStackElement{}, SortStack{}) : SortStack{} [functional{}(), constructor{}(), userList{}("*"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("010"), klabel{}("Stack"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(37,20,37,58)"), left{}(), format{}("%1 %c;%r %2"), injective{}()] + symbol Lbl'UndsSClnUndsUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockList'Unds'Block'Unds'BlockList{}(SortBlock{}, SortBlockList{}) : SortBlockList{} [functional{}(), constructor{}(), userList{}("*"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("010"), klabel{}("BlockList"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(585,24,585,59)"), left{}(), format{}("%1 %c;%r %2"), injective{}()] + symbol Lbl'UndsSClnUndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'StackElementList'Unds'StackElementLiteral'Unds'StackElementList{}(SortStackElementLiteral{}, SortStackElementList{}) : SortStackElementList{} [functional{}(), constructor{}(), userList{}("*"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("010"), klabel{}("StackElementList"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(651,31,651,89)"), left{}(), format{}("%1 %c;%r %2"), injective{}()] + hooked-symbol Lbl'Unds-LT--LT-'Int'Unds'{}(SortInt{}, SortInt{}) : SortInt{} [latex{}("{#1}\\mathrel{\\ll_{\\scriptstyle\\it Int}}{#2}"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(Lbl'Unds'xorInt'Unds'{}(),Lbl'UndsAnd-'Int'Unds'{}(),Lbl'UndsPipe'Int'Unds'{}()), right{}(), smtlib{}("shlInt"), terminals{}("010"), klabel{}("_<="), right{}(), terminals{}("010"), klabel{}("_>=Int_"), hook{}("INT.ge"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(965,19,965,176)"), left{}(Lbl'Unds-GT-Eqls'Int'Unds'{}()), format{}("%1 %c>=Int%r %2"), function{}()] + hooked-symbol Lbl'Unds-GT-Eqls'String'UndsUnds'STRING-COMMON'Unds'Bool'Unds'String'Unds'String{}(SortString{}, SortString{}) : SortBool{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("010"), hook{}("STRING.ge"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1474,19,1474,82)"), left{}(), format{}("%1 %c>=String%r %2"), function{}()] + hooked-symbol Lbl'Unds-GT--GT-'Int'Unds'{}(SortInt{}, SortInt{}) : SortInt{} [latex{}("{#1}\\mathrel{\\gg_{\\scriptstyle\\it Int}}{#2}"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(Lbl'Unds'xorInt'Unds'{}(),Lbl'UndsAnd-'Int'Unds'{}(),Lbl'UndsPipe'Int'Unds'{}()), right{}(), smtlib{}("shrInt"), terminals{}("010"), klabel{}("_>>Int_"), hook{}("INT.shr"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(904,18,904,172)"), left{}(Lbl'Unds-LT--LT-'Int'Unds'{}(),Lbl'Unds-GT--GT-'Int'Unds'{}()), format{}("%1 %c>>Int%r %2"), function{}()] + hooked-symbol Lbl'Unds-GT-'Int'Unds'{}(SortInt{}, SortInt{}) : SortBool{} [latex{}("{#1}\\mathrel{>_{\\scriptstyle\\it Int}}{#2}"), functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), smt-hook{}(">"), right{}(), terminals{}("010"), klabel{}("_>Int_"), hook{}("INT.gt"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(966,19,966,171)"), left{}(Lbl'Unds-GT-'Int'Unds'{}()), format{}("%1 %c>Int%r %2"), function{}()] + hooked-symbol Lbl'Unds-GT-'String'UndsUnds'STRING-COMMON'Unds'Bool'Unds'String'Unds'String{}(SortString{}, SortString{}) : SortBool{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("010"), hook{}("STRING.gt"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1473,19,1473,82)"), left{}(), format{}("%1 %c>String%r %2"), function{}()] + hooked-symbol Lbl'Unds'List'Unds'{}(SortList{}, SortList{}) : SortList{} [unit{}(".List"), functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), element{}("ListItem"), symbol'Kywd'{}(), priorities{}(), right{}(), assoc{}(), smtlib{}("smt_seq_concat"), terminals{}("00"), klabel{}("_List_"), hook{}("LIST.concat"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(611,19,611,192)"), left{}(Lbl'Unds'List'Unds'{}()), format{}("%1%n%2"), function{}()] + hooked-symbol Lbl'Unds'Map'Unds'{}(SortMap{}, SortMap{}) : SortMap{} [unit{}(".Map"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), element{}("_|->_"), symbol'Kywd'{}(), comm{}(), priorities{}(), right{}(), assoc{}(), terminals{}("00"), index{}("0"), klabel{}("_Map_"), hook{}("MAP.concat"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(241,18,241,172)"), left{}(Lbl'Unds'Map'Unds'{}()), format{}("%1%n%2"), function{}()] + hooked-symbol Lbl'Unds'Set'Unds'{}(SortSet{}, SortSet{}) : SortSet{} [unit{}(".Set"), functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), element{}("SetItem"), symbol'Kywd'{}(), idem{}(), comm{}(), priorities{}(), right{}(), assoc{}(), terminals{}("00"), klabel{}("_Set_"), hook{}("SET.concat"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(491,18,491,176)"), left{}(Lbl'Unds'Set'Unds'{}()), format{}("%1%n%2"), function{}()] + hooked-symbol Lbl'UndsLSqBUnds-LT-'-'UndsRSqBUnds'BYTES-HOOKED'Unds'Bytes'Unds'Bytes'Unds'Int'Unds'Int{}(SortBytes{}, SortInt{}, SortInt{}) : SortBytes{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("010101"), hook{}("BYTES.update"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1688,20,1688,90)"), left{}(), format{}("%1 %c[%r %2 %c<-%r %3 %c]%r"), function{}()] + hooked-symbol Lbl'UndsLSqBUnds-LT-'-'UndsRSqBUnds'LIST'Unds'List'Unds'List'Unds'Int'Unds'KItem{}(SortList{}, SortInt{}, SortKItem{}) : SortList{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("010101"), klabel{}("List:set"), hook{}("LIST.update"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(647,19,647,107)"), left{}(), format{}("%1 %c[%r %2 %c<-%r %3 %c]%r"), function{}()] + hooked-symbol Lbl'UndsLSqBUnds-LT-'-undef'RSqB'{}(SortMap{}, SortKItem{}) : SortMap{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("010111"), klabel{}("_[_<-undef]"), hook{}("MAP.remove"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(300,18,300,121)"), left{}(), format{}("%1 %c[%r %2 %c<-%r %cundef%r %c]%r"), function{}()] + hooked-symbol Lbl'UndsLSqBUndsRSqBUnds'BYTES-HOOKED'Unds'Int'Unds'Bytes'Unds'Int{}(SortBytes{}, SortInt{}) : SortInt{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("0101"), hook{}("BYTES.get"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1697,18,1697,62)"), left{}(), format{}("%1 %c[%r %2 %c]%r"), function{}()] + hooked-symbol Lbl'UndsLSqBUndsRSqB'orDefault'UndsUnds'MAP'Unds'KItem'Unds'Map'Unds'KItem'Unds'KItem{}(SortMap{}, SortKItem{}, SortKItem{}) : SortKItem{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("010110"), klabel{}("Map:lookupOrDefault"), hook{}("MAP.lookupOrDefault"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(282,20,282,138)"), left{}(), format{}("%1 %c[%r %2 %c]%r %corDefault%r %3"), function{}()] + hooked-symbol Lbl'UndsXor-Perc'Int'UndsUnds'{}(SortInt{}, SortInt{}, SortInt{}) : SortInt{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(Lbl'UndsPlus'Int'Unds'{}(),Lbl'Unds'divInt'Unds'{}(),Lbl'UndsPerc'Int'Unds'{}(),Lbl'Unds-GT--GT-'Int'Unds'{}(),Lbl'Unds'xorInt'Unds'{}(),Lbl'UndsSlsh'Int'Unds'{}(),Lbl'UndsAnd-'Int'Unds'{}(),Lbl'Unds-LT--LT-'Int'Unds'{}(),Lbl'UndsStar'Int'Unds'{}(),Lbl'UndsPipe'Int'Unds'{}(),Lbl'Unds'modInt'Unds'{}(),Lbl'Unds'-Int'Unds'{}()), smt-hook{}("(mod (^ #1 #2) #3)"), right{}(), terminals{}("0100"), klabel{}("_^%Int__"), hook{}("INT.powmod"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(890,18,890,138)"), left{}(Lbl'UndsXor-Perc'Int'UndsUnds'{}(),Lbl'UndsXor-'Int'Unds'{}()), format{}("%1 %c^%%Int%r %2 %3"), function{}()] + hooked-symbol Lbl'UndsXor-'Int'Unds'{}(SortInt{}, SortInt{}) : SortInt{} [latex{}("{#1}\\mathrel{{\\char`\\^}_{\\!\\scriptstyle\\it Int}}{#2}"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(Lbl'UndsPlus'Int'Unds'{}(),Lbl'Unds'divInt'Unds'{}(),Lbl'UndsPerc'Int'Unds'{}(),Lbl'Unds-GT--GT-'Int'Unds'{}(),Lbl'Unds'xorInt'Unds'{}(),Lbl'UndsSlsh'Int'Unds'{}(),Lbl'UndsAnd-'Int'Unds'{}(),Lbl'Unds-LT--LT-'Int'Unds'{}(),Lbl'UndsStar'Int'Unds'{}(),Lbl'UndsPipe'Int'Unds'{}(),Lbl'Unds'modInt'Unds'{}(),Lbl'Unds'-Int'Unds'{}()), smt-hook{}("^"), right{}(), terminals{}("010"), klabel{}("_^Int_"), hook{}("INT.pow"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(889,18,889,177)"), left{}(Lbl'UndsXor-'Int'Unds'{}(),Lbl'UndsXor-Perc'Int'UndsUnds'{}()), format{}("%1 %c^Int%r %2"), function{}()] + symbol Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList{}(SortAnnotation{}, SortAnnotationList{}) : SortAnnotationList{} [functional{}(), constructor{}(), userList{}("*"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("010"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(74,29,74,48)"), left{}(), format{}("%1 %c%r %2"), injective{}()] + symbol Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(SortNullaryTypeName{}, SortAnnotationList{}) : SortType{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("00"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(187,19,187,48)"), left{}(), format{}("%1 %2"), injective{}()] + symbol Lbl'UndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'UnaryTypeName'Unds'TypeName{}(SortUnaryTypeName{}, SortTypeName{}) : SortTypeName{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("00"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(20,23,20,44)"), left{}(), format{}("%1 %2"), injective{}()] + symbol Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(SortUnaryTypeName{}, SortAnnotationList{}, SortType{}) : SortType{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("000"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(188,19,188,53)"), left{}(), format{}("%1 %2 %3"), injective{}()] + symbol Lbl'UndsUndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'BinaryTypeName'Unds'TypeName'Unds'TypeName{}(SortBinaryTypeName{}, SortTypeName{}, SortTypeName{}) : SortTypeName{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("000"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(21,23,21,54)"), left{}(), format{}("%1 %2 %3"), injective{}()] + symbol Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(SortBinaryTypeName{}, SortAnnotationList{}, SortType{}, SortType{}) : SortType{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("0000"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(189,19,189,58)"), left{}(), format{}("%1 %2 %3 %4"), injective{}()] + hooked-symbol Lbl'Unds'andBool'Unds'{}(SortBool{}, SortBool{}) : SortBool{} [latex{}("{#1}\\wedge_{\\scriptstyle\\it Bool}{#2}"), functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(Lbl'UndsEqlsSlshEqls'Bool'Unds'{}(),Lbl'UndsEqlsEqls'Bool'Unds'{}()), smt-hook{}("and"), boolOperation{}(), right{}(), terminals{}("010"), klabel{}("_andBool_"), hook{}("BOOL.and"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(779,19,779,189)"), left{}(Lbl'Unds'andBool'Unds'{}()), format{}("%1 %candBool%r %2"), function{}()] + hooked-symbol Lbl'Unds'andThenBool'Unds'{}(SortBool{}, SortBool{}) : SortBool{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(Lbl'UndsEqlsSlshEqls'Bool'Unds'{}(),Lbl'UndsEqlsEqls'Bool'Unds'{}()), smt-hook{}("and"), boolOperation{}(), right{}(), terminals{}("010"), klabel{}("_andThenBool_"), hook{}("BOOL.andThen"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(780,19,780,151)"), left{}(Lbl'Unds'andThenBool'Unds'{}()), format{}("%1 %candThenBool%r %2"), function{}()] + hooked-symbol Lbl'Unds'divInt'Unds'{}(SortInt{}, SortInt{}) : SortInt{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(Lbl'UndsPlus'Int'Unds'{}(),Lbl'Unds-GT--GT-'Int'Unds'{}(),Lbl'Unds'xorInt'Unds'{}(),Lbl'UndsAnd-'Int'Unds'{}(),Lbl'Unds-LT--LT-'Int'Unds'{}(),Lbl'UndsPipe'Int'Unds'{}(),Lbl'Unds'-Int'Unds'{}()), smt-hook{}("div"), right{}(), terminals{}("010"), klabel{}("_divInt_"), hook{}("INT.ediv"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(898,18,898,121)"), left{}(Lbl'UndsSlsh'Int'Unds'{}(),Lbl'Unds'modInt'Unds'{}(),Lbl'UndsStar'Int'Unds'{}(),Lbl'UndsPerc'Int'Unds'{}(),Lbl'Unds'divInt'Unds'{}()), format{}("%1 %cdivInt%r %2"), function{}()] + symbol Lbl'Unds'dividesInt'UndsUnds'INT-COMMON'Unds'Bool'Unds'Int'Unds'Int{}(SortInt{}, SortInt{}) : SortBool{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("010"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(977,19,977,52)"), left{}(), format{}("%1 %cdividesInt%r %2"), function{}()] + hooked-symbol Lbl'Unds'impliesBool'Unds'{}(SortBool{}, SortBool{}) : SortBool{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(Lbl'UndsEqlsSlshEqls'Bool'Unds'{}(),Lbl'UndsEqlsEqls'Bool'Unds'{}()), smt-hook{}("=>"), boolOperation{}(), right{}(), terminals{}("010"), klabel{}("_impliesBool_"), hook{}("BOOL.implies"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(784,19,784,150)"), left{}(Lbl'Unds'impliesBool'Unds'{}()), format{}("%1 %cimpliesBool%r %2"), function{}()] + hooked-symbol Lbl'Unds'in'UndsUnds'LIST'Unds'Bool'Unds'KItem'Unds'List{}(SortKItem{}, SortList{}) : SortBool{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("010"), klabel{}("_inList_"), hook{}("LIST.in"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(694,19,694,101)"), left{}(), format{}("%1 %cin%r %2"), function{}()] + hooked-symbol Lbl'Unds'in'Unds'keys'LParUndsRParUnds'MAP'Unds'Bool'Unds'KItem'Unds'Map{}(SortKItem{}, SortMap{}) : SortBool{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("01101"), hook{}("MAP.in_keys"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(358,19,358,93)"), left{}(), format{}("%1 %cin_keys%r %c(%r %2 %c)%r"), function{}()] + hooked-symbol Lbl'Unds'modInt'Unds'{}(SortInt{}, SortInt{}) : SortInt{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(Lbl'UndsPlus'Int'Unds'{}(),Lbl'Unds-GT--GT-'Int'Unds'{}(),Lbl'Unds'xorInt'Unds'{}(),Lbl'UndsAnd-'Int'Unds'{}(),Lbl'Unds-LT--LT-'Int'Unds'{}(),Lbl'UndsPipe'Int'Unds'{}(),Lbl'Unds'-Int'Unds'{}()), smt-hook{}("mod"), right{}(), terminals{}("010"), klabel{}("_modInt_"), hook{}("INT.emod"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(899,18,899,121)"), left{}(Lbl'UndsStar'Int'Unds'{}(),Lbl'UndsPerc'Int'Unds'{}(),Lbl'Unds'divInt'Unds'{}(),Lbl'UndsSlsh'Int'Unds'{}(),Lbl'Unds'modInt'Unds'{}()), format{}("%1 %cmodInt%r %2"), function{}()] + hooked-symbol Lbl'Unds'orBool'UndsUnds'BOOL'Unds'Bool'Unds'Bool'Unds'Bool{}(SortBool{}, SortBool{}) : SortBool{} [latex{}("{#1}\\vee_{\\scriptstyle\\it Bool}{#2}"), functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(Lbl'UndsEqlsSlshEqls'Bool'Unds'{}(),Lbl'UndsEqlsEqls'Bool'Unds'{}()), smt-hook{}("or"), boolOperation{}(), right{}(), terminals{}("010"), klabel{}("_orBool_"), hook{}("BOOL.or"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(782,19,782,176)"), left{}(Lbl'Unds'orBool'UndsUnds'BOOL'Unds'Bool'Unds'Bool'Unds'Bool{}()), format{}("%1 %corBool%r %2"), function{}()] + hooked-symbol Lbl'Unds'orElseBool'Unds'{}(SortBool{}, SortBool{}) : SortBool{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(Lbl'UndsEqlsSlshEqls'Bool'Unds'{}(),Lbl'UndsEqlsEqls'Bool'Unds'{}()), smt-hook{}("or"), boolOperation{}(), right{}(), terminals{}("010"), klabel{}("_orElseBool_"), hook{}("BOOL.orElse"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(783,19,783,148)"), left{}(Lbl'Unds'orElseBool'Unds'{}()), format{}("%1 %corElseBool%r %2"), function{}()] + hooked-symbol Lbl'Unds'xorBool'Unds'{}(SortBool{}, SortBool{}) : SortBool{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(Lbl'UndsEqlsSlshEqls'Bool'Unds'{}(),Lbl'UndsEqlsEqls'Bool'Unds'{}()), smt-hook{}("xor"), boolOperation{}(), right{}(), terminals{}("010"), klabel{}("_xorBool_"), hook{}("BOOL.xor"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(781,19,781,143)"), left{}(Lbl'Unds'xorBool'Unds'{}()), format{}("%1 %cxorBool%r %2"), function{}()] + hooked-symbol Lbl'Unds'xorInt'Unds'{}(SortInt{}, SortInt{}) : SortInt{} [latex{}("{#1}\\mathrel{\\oplus_{\\scriptstyle\\it Int}}{#2}"), functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(Lbl'UndsPipe'Int'Unds'{}()), right{}(), smtlib{}("xorInt"), terminals{}("010"), klabel{}("_xorInt_"), hook{}("INT.xor"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(909,18,909,188)"), left{}(Lbl'Unds'xorInt'Unds'{}()), format{}("%1 %cxorInt%r %2"), function{}()] + symbol Lbl'UndsLBraUndsRBraUnds'SYMBOLIC-UNIT-TEST-COMMON-SYNTAX'Unds'Invariant'Unds'LiteralStack'Unds'BlockList{}(SortLiteralStack{}, SortBlockList{}) : SortInvariant{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("0101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(767,24,767,53)"), left{}(), format{}("%1 %c{%r %2 %c}%r"), injective{}()] + hooked-symbol Lbl'UndsPipe'-'-GT-Unds'{}(SortKItem{}, SortKItem{}) : SortMap{} [latex{}("{#1}\\mapsto{#2}"), functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(Lbl'Stop'Map{}(),Lbl'Unds'Map'Unds'{}()), right{}(Lbl'UndsPipe'-'-GT-Unds'{}()), terminals{}("010"), klabel{}("_|->_"), hook{}("MAP.element"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(258,18,258,144)"), left{}(Lbl'UndsPipe'-'-GT-Unds'{}()), format{}("%1 %c|->%r %2"), function{}()] + hooked-symbol Lbl'UndsPipe'Int'Unds'{}(SortInt{}, SortInt{}) : SortInt{} [latex{}("{#1}\\mathrel{|_{\\scriptstyle\\it Int}}{#2}"), functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), smtlib{}("orInt"), terminals{}("010"), klabel{}("_|Int_"), hook{}("INT.or"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(911,18,911,179)"), left{}(Lbl'UndsPipe'Int'Unds'{}()), format{}("%1 %c|Int%r %2"), function{}()] + hooked-symbol Lbl'UndsPipe'Set'UndsUnds'SET'Unds'Set'Unds'Set'Unds'Set{}(SortSet{}, SortSet{}) : SortSet{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("010"), hook{}("SET.union"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(518,18,518,88)"), left{}(Lbl'UndsPipe'Set'UndsUnds'SET'Unds'Set'Unds'Set'Unds'Set{}()), format{}("%1 %c|Set%r %2"), function{}()] + hooked-symbol LblabsInt'LParUndsRParUnds'INT-COMMON'Unds'Int'Unds'Int{}(SortInt{}) : SortInt{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), smt-hook{}("(ite (< #1 0) (- 0 #1) #1)"), right{}(), terminals{}("1101"), klabel{}("absInt"), hook{}("INT.abs"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(928,18,928,123)"), left{}(), format{}("%cabsInt%r %c(%r %1 %c)%r"), function{}()] + symbol Lbladdress'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}() : SortNullaryTypeName{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(168,30,168,38)"), left{}(), format{}("%caddress%r"), injective{}()] + symbol Lblamount'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AmountGroup'Unds'Int{}(SortInt{}) : SortAmountGroup{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(360,26,360,37)"), left{}(), format{}("%camount%r %1"), injective{}()] + symbol Lblbalance'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BalanceGroup'Unds'Int{}(SortInt{}) : SortBalanceGroup{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(361,27,361,39)"), left{}(), format{}("%cbalance%r %1"), injective{}()] + symbol LblbigEndianBytes{}() : SortEndianness{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("bigEndianBytes"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1626,25,1626,61)"), left{}(), format{}("%cBE%r"), injective{}()] + symbol Lblbig'Unds'map'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}() : SortMapTypeName{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(180,34,180,42)"), left{}(), format{}("%cbig_map%r"), injective{}()] + symbol Lblbig'Unds'maps'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapGroup'Unds'BigMapEntryList{}(SortBigMapEntryList{}) : SortBigMapGroup{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(365,26,365,59)"), left{}(), format{}("%cbig_maps%r %c{%r %1 %c}%r"), injective{}()] + hooked-symbol LblbitRangeInt'LParUndsCommUndsCommUndsRParUnds'INT-COMMON'Unds'Int'Unds'Int'Unds'Int'Unds'Int{}(SortInt{}, SortInt{}, SortInt{}) : SortInt{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("11010101"), klabel{}("bitRangeInt"), hook{}("INT.bitRange"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(953,18,953,102)"), left{}(), format{}("%cbitRangeInt%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), function{}()] + symbol Lblbool'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}() : SortNullaryTypeName{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(165,30,165,35)"), left{}(), format{}("%cbool%r"), injective{}()] + symbol Lblbytes'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}() : SortNullaryTypeName{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(163,30,163,36)"), left{}(), format{}("%cbytes%r"), injective{}()] + hooked-symbol LblcategoryChar'LParUndsRParUnds'STRING-COMMON'Unds'String'Unds'String{}(SortString{}) : SortString{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("categoryChar"), hook{}("STRING.category"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1484,21,1484,80)"), left{}(), format{}("%ccategoryChar%r %c(%r %1 %c)%r"), function{}()] + symbol Lblchain'Unds'id'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}() : SortNullaryTypeName{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(173,30,173,39)"), left{}(), format{}("%cchain_id%r"), injective{}()] + symbol Lblchain'Unds'id'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'ChainGroup'Unds'MBytes{}(SortMBytes{}) : SortChainGroup{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(358,25,358,41)"), left{}(), format{}("%cchain_id%r %1"), injective{}()] + hooked-symbol Lblchoice'LParUndsRParUnds'MAP'Unds'KItem'Unds'Map{}(SortMap{}) : SortKItem{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("Map:choice"), hook{}("MAP.choice"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(394,20,394,100)"), left{}(), format{}("%cchoice%r %c(%r %1 %c)%r"), function{}()] + hooked-symbol Lblchoice'LParUndsRParUnds'SET'Unds'KItem'Unds'Set{}(SortSet{}) : SortKItem{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("Set:choice"), hook{}("SET.choice"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(574,20,574,94)"), left{}(), format{}("%cchoice%r %c(%r %1 %c)%r"), function{}()] + hooked-symbol LblchrChar'LParUndsRParUnds'STRING-COMMON'Unds'String'Unds'Int{}(SortInt{}) : SortString{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("chrChar"), hook{}("STRING.chr"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1364,21,1364,69)"), left{}(), format{}("%cchrChar%r %c(%r %1 %c)%r"), function{}()] + symbol Lblcode'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'CodeDecl'Unds'Block{}(SortBlock{}) : SortCodeDecl{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(299,23,299,34)"), left{}(), format{}("%ccode%r %1"), injective{}()] + symbol Lblcontract'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}() : SortUnaryTypeName{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(178,30,178,39)"), left{}(), format{}("%ccontract%r"), injective{}()] + symbol Lblcontract'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'ContractGroup'Unds'Contract{}(SortContract{}) : SortContractGroup{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(354,28,354,54)"), left{}(), format{}("%ccontract%r %c{%r %1 %c}%r"), injective{}()] + hooked-symbol LblcountAllOccurrences'LParUndsCommUndsRParUnds'STRING-COMMON'Unds'Int'Unds'String'Unds'String{}(SortString{}, SortString{}) : SortInt{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("110101"), hook{}("STRING.countAllOccurrences"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1457,18,1457,150)"), left{}(), format{}("%ccountAllOccurrences%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + hooked-symbol LbldirectionalityChar'LParUndsRParUnds'STRING-COMMON'Unds'String'Unds'String{}(SortString{}) : SortString{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("directionalityChar"), hook{}("STRING.directionality"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1485,21,1485,86)"), left{}(), format{}("%cdirectionalityChar%r %c(%r %1 %c)%r"), function{}()] + hooked-symbol LblfillList'LParUndsCommUndsCommUndsCommUndsRParUnds'LIST'Unds'List'Unds'List'Unds'Int'Unds'Int'Unds'KItem{}(SortList{}, SortInt{}, SortInt{}, SortKItem{}) : SortList{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101010101"), klabel{}("fillList"), hook{}("LIST.fill"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(675,19,675,99)"), left{}(), format{}("%cfillList%r %c(%r %1 %c,%r %2 %c,%r %3 %c,%r %4 %c)%r"), function{}()] + hooked-symbol LblfindChar'LParUndsCommUndsCommUndsRParUnds'STRING-COMMON'Unds'Int'Unds'String'Unds'String'Unds'Int{}(SortString{}, SortString{}, SortInt{}) : SortInt{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("11010101"), klabel{}("findChar"), hook{}("STRING.findChar"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1395,18,1395,115)"), left{}(), format{}("%cfindChar%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), function{}()] + hooked-symbol LblfindString'LParUndsCommUndsCommUndsRParUnds'STRING-COMMON'Unds'Int'Unds'String'Unds'String'Unds'Int{}(SortString{}, SortString{}, SortInt{}) : SortInt{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("11010101"), klabel{}("findString"), hook{}("STRING.find"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1384,18,1384,110)"), left{}(), format{}("%cfindString%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), function{}()] + symbol LblfreshId'LParUndsRParUnds'ID-COMMON'Unds'Id'Unds'Int{}(SortInt{}) : SortId{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), freshGenerator{}(), klabel{}("freshId"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1925,17,1925,70)"), left{}(), format{}("%cfreshId%r %c(%r %1 %c)%r"), function{}()] + symbol LblfreshInt'LParUndsRParUnds'INT'Unds'Int'Unds'Int{}(SortInt{}) : SortInt{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), freshGenerator{}(), klabel{}("freshInt"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1079,18,1079,72)"), left{}(), format{}("%cfreshInt%r %c(%r %1 %c)%r"), function{}()] + symbol LblgetExitCode{}(SortGeneratedTopCell{}) : SortInt{} [priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cgetExitCode%r %c(%r %1 %c)%r"), function{}()] + symbol LblgetGeneratedCounterCell{}(SortGeneratedTopCell{}) : SortGeneratedCounterCell{} [priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cgetGeneratedCounterCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblgroupSemicolon{}(SortGroup{}) : SortGroups{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), anywhere{}(), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1101"), klabel{}("groupSemicolon"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(594,21,594,74)"), left{}(), format{}("%cgroupSemicolon%r %c(%r %1 %c)%r"), injective{}()] + symbol LblinitAssumeFailedCell{}() : SortAssumeFailedCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitAssumeFailedCell%r"), function{}()] + symbol LblinitBigmapsCell{}() : SortBigmapsCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitBigmapsCell%r"), function{}()] + symbol LblinitCutpointsCell{}() : SortCutpointsCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitCutpointsCell%r"), function{}()] + symbol LblinitExpectedCell{}() : SortExpectedCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitExpectedCell%r"), function{}()] + symbol LblinitGeneratedCounterCell{}() : SortGeneratedCounterCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitGeneratedCounterCell%r"), function{}()] + symbol LblinitGeneratedTopCell{}(SortMap{}) : SortGeneratedTopCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1101"), left{}(), initializer{}(), format{}("%cinitGeneratedTopCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblinitInputstackCell{}() : SortInputstackCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitInputstackCell%r"), function{}()] + symbol LblinitInvsCell{}() : SortInvsCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitInvsCell%r"), function{}()] + symbol LblinitKCell{}(SortMap{}) : SortKCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1101"), left{}(), initializer{}(), format{}("%cinitKCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblinitKnownaddrsCell{}() : SortKnownaddrsCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitKnownaddrsCell%r"), function{}()] + symbol LblinitMichelsonTopCell{}(SortMap{}) : SortMichelsonTopCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1101"), left{}(), initializer{}(), format{}("%cinitMichelsonTopCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblinitMyaddrCell{}() : SortMyaddrCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitMyaddrCell%r"), function{}()] + symbol LblinitMyamountCell{}() : SortMyamountCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitMyamountCell%r"), function{}()] + symbol LblinitMybalanceCell{}() : SortMybalanceCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitMybalanceCell%r"), function{}()] + symbol LblinitMychainidCell{}() : SortMychainidCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitMychainidCell%r"), function{}()] + symbol LblinitMynowCell{}() : SortMynowCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitMynowCell%r"), function{}()] + symbol LblinitNonceCell{}() : SortNonceCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitNonceCell%r"), function{}()] + symbol LblinitParamtypeCell{}() : SortParamtypeCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitParamtypeCell%r"), function{}()] + symbol LblinitParamvalueCell{}() : SortParamvalueCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitParamvalueCell%r"), function{}()] + symbol LblinitPostCell{}() : SortPostCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitPostCell%r"), function{}()] + symbol LblinitPreCell{}() : SortPreCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitPreCell%r"), function{}()] + symbol LblinitReturncodeCell{}() : SortReturncodeCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitReturncodeCell%r"), function{}()] + symbol LblinitScriptCell{}() : SortScriptCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitScriptCell%r"), function{}()] + symbol LblinitSenderaddrCell{}() : SortSenderaddrCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitSenderaddrCell%r"), function{}()] + symbol LblinitSourceaddrCell{}() : SortSourceaddrCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitSourceaddrCell%r"), function{}()] + symbol LblinitStackCell{}() : SortStackCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitStackCell%r"), function{}()] + symbol LblinitStoragetypeCell{}() : SortStoragetypeCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitStoragetypeCell%r"), function{}()] + symbol LblinitStoragevalueCell{}() : SortStoragevalueCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitStoragevalueCell%r"), function{}()] + symbol LblinitSymbolsCell{}() : SortSymbolsCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitSymbolsCell%r"), function{}()] + symbol LblinitTraceCell{}() : SortTraceCell{} [noThread{}(), priorities{}(), right{}(), terminals{}("1"), left{}(), initializer{}(), format{}("%cinitTraceCell%r"), function{}()] + symbol Lblinput'UndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'InputGroup'Unds'LiteralStack{}(SortLiteralStack{}) : SortInputGroup{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(682,25,682,44)"), left{}(), format{}("%cinput%r %1"), injective{}()] + symbol Lblint'Unds'MICHELSON-COMMON-SYNTAX'Unds'NumTypeName{}() : SortNumTypeName{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(159,26,159,30)"), left{}(), format{}("%cint%r"), injective{}()] + hooked-symbol LblintersectSet'LParUndsCommUndsRParUnds'SET'Unds'Set'Unds'Set'Unds'Set{}(SortSet{}, SortSet{}) : SortSet{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("intersectSet"), hook{}("SET.intersection"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(529,18,529,88)"), left{}(), format{}("%cintersectSet%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + symbol Lblinvariant'UndsUndsUnds'SYMBOLIC-UNIT-TEST-COMMON-SYNTAX'Unds'InvariantsGroup'Unds'VariableAnnotation'Unds'Invariant{}(SortVariableAnnotation{}, SortInvariant{}) : SortInvariantsGroup{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("100"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(766,30,766,69)"), left{}(), format{}("%cinvariant%r %1 %2"), injective{}()] + symbol LblisAddress{}(SortK{}) : SortBool{} [predicate{}("Address"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisAddress%r %c(%r %1 %c)%r"), function{}()] + symbol LblisAmountGroup{}(SortK{}) : SortBool{} [predicate{}("AmountGroup"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisAmountGroup%r %c(%r %1 %c)%r"), function{}()] + symbol LblisAnnotation{}(SortK{}) : SortBool{} [predicate{}("Annotation"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisAnnotation%r %c(%r %1 %c)%r"), function{}()] + symbol LblisAnnotationList{}(SortK{}) : SortBool{} [predicate{}("AnnotationList"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisAnnotationList%r %c(%r %1 %c)%r"), function{}()] + symbol LblisAssumeFailedCell{}(SortK{}) : SortBool{} [predicate{}("AssumeFailedCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisAssumeFailedCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisAssumeFailedCellOpt{}(SortK{}) : SortBool{} [predicate{}("AssumeFailedCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisAssumeFailedCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisBalanceGroup{}(SortK{}) : SortBool{} [predicate{}("BalanceGroup"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisBalanceGroup%r %c(%r %1 %c)%r"), function{}()] + symbol LblisBigMapEntry{}(SortK{}) : SortBool{} [predicate{}("BigMapEntry"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisBigMapEntry%r %c(%r %1 %c)%r"), function{}()] + symbol LblisBigMapEntryList{}(SortK{}) : SortBool{} [predicate{}("BigMapEntryList"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisBigMapEntryList%r %c(%r %1 %c)%r"), function{}()] + symbol LblisBigMapGroup{}(SortK{}) : SortBool{} [predicate{}("BigMapGroup"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisBigMapGroup%r %c(%r %1 %c)%r"), function{}()] + symbol LblisBigmapsCell{}(SortK{}) : SortBool{} [predicate{}("BigmapsCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisBigmapsCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisBigmapsCellOpt{}(SortK{}) : SortBool{} [predicate{}("BigmapsCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisBigmapsCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisBinaryTypeName{}(SortK{}) : SortBool{} [predicate{}("BinaryTypeName"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisBinaryTypeName%r %c(%r %1 %c)%r"), function{}()] + symbol LblisBlock{}(SortK{}) : SortBool{} [predicate{}("Block"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisBlock%r %c(%r %1 %c)%r"), function{}()] + symbol LblisBlockList{}(SortK{}) : SortBool{} [predicate{}("BlockList"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisBlockList%r %c(%r %1 %c)%r"), function{}()] + symbol LblisBlockchainOperation{}(SortK{}) : SortBool{} [predicate{}("BlockchainOperation"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisBlockchainOperation%r %c(%r %1 %c)%r"), function{}()] + symbol LblisBool{}(SortK{}) : SortBool{} [predicate{}("Bool"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisBool%r %c(%r %1 %c)%r"), function{}()] + symbol LblisBoolExp{}(SortK{}) : SortBool{} [predicate{}("BoolExp"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisBoolExp%r %c(%r %1 %c)%r"), function{}()] + symbol LblisBytes{}(SortK{}) : SortBool{} [predicate{}("Bytes"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisBytes%r %c(%r %1 %c)%r"), function{}()] + symbol LblisCell{}(SortK{}) : SortBool{} [predicate{}("Cell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisChainGroup{}(SortK{}) : SortBool{} [predicate{}("ChainGroup"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisChainGroup%r %c(%r %1 %c)%r"), function{}()] + symbol LblisChainId{}(SortK{}) : SortBool{} [predicate{}("ChainId"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisChainId%r %c(%r %1 %c)%r"), function{}()] + symbol LblisCodeDecl{}(SortK{}) : SortBool{} [predicate{}("CodeDecl"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisCodeDecl%r %c(%r %1 %c)%r"), function{}()] + symbol LblisCodeGroup{}(SortK{}) : SortBool{} [predicate{}("CodeGroup"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisCodeGroup%r %c(%r %1 %c)%r"), function{}()] + symbol LblisContract{}(SortK{}) : SortBool{} [predicate{}("Contract"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisContract%r %c(%r %1 %c)%r"), function{}()] + symbol LblisContractData{}(SortK{}) : SortBool{} [predicate{}("ContractData"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisContractData%r %c(%r %1 %c)%r"), function{}()] + symbol LblisContractGroup{}(SortK{}) : SortBool{} [predicate{}("ContractGroup"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisContractGroup%r %c(%r %1 %c)%r"), function{}()] + symbol LblisContractsGroup{}(SortK{}) : SortBool{} [predicate{}("ContractsGroup"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisContractsGroup%r %c(%r %1 %c)%r"), function{}()] + symbol LblisCutpointsCell{}(SortK{}) : SortBool{} [predicate{}("CutpointsCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisCutpointsCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisCutpointsCellOpt{}(SortK{}) : SortBool{} [predicate{}("CutpointsCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisCutpointsCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisData{}(SortK{}) : SortBool{} [predicate{}("Data"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisData%r %c(%r %1 %c)%r"), function{}()] + symbol LblisDataList{}(SortK{}) : SortBool{} [predicate{}("DataList"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisDataList%r %c(%r %1 %c)%r"), function{}()] + symbol LblisDataOrSeq{}(SortK{}) : SortBool{} [predicate{}("DataOrSeq"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisDataOrSeq%r %c(%r %1 %c)%r"), function{}()] + symbol LblisEmptyBlock{}(SortK{}) : SortBool{} [predicate{}("EmptyBlock"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisEmptyBlock%r %c(%r %1 %c)%r"), function{}()] + symbol LblisEndianness{}(SortK{}) : SortBool{} [predicate{}("Endianness"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisEndianness%r %c(%r %1 %c)%r"), function{}()] + symbol LblisError{}(SortK{}) : SortBool{} [predicate{}("Error"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisError%r %c(%r %1 %c)%r"), function{}()] + symbol LblisExpectedCell{}(SortK{}) : SortBool{} [predicate{}("ExpectedCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisExpectedCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisExpectedCellOpt{}(SortK{}) : SortBool{} [predicate{}("ExpectedCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisExpectedCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisFailedStack{}(SortK{}) : SortBool{} [predicate{}("FailedStack"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisFailedStack%r %c(%r %1 %c)%r"), function{}()] + symbol LblisFieldAnnotation{}(SortK{}) : SortBool{} [predicate{}("FieldAnnotation"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisFieldAnnotation%r %c(%r %1 %c)%r"), function{}()] + symbol LblisFloat{}(SortK{}) : SortBool{} [predicate{}("Float"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisFloat%r %c(%r %1 %c)%r"), function{}()] + symbol LblisGeneratedCounterCell{}(SortK{}) : SortBool{} [predicate{}("GeneratedCounterCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisGeneratedCounterCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisGeneratedCounterCellOpt{}(SortK{}) : SortBool{} [predicate{}("GeneratedCounterCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisGeneratedCounterCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisGeneratedTopCell{}(SortK{}) : SortBool{} [predicate{}("GeneratedTopCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisGeneratedTopCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisGeneratedTopCellFragment{}(SortK{}) : SortBool{} [predicate{}("GeneratedTopCellFragment"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisGeneratedTopCellFragment%r %c(%r %1 %c)%r"), function{}()] + symbol LblisGroup{}(SortK{}) : SortBool{} [predicate{}("Group"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisGroup%r %c(%r %1 %c)%r"), function{}()] + symbol LblisGroups{}(SortK{}) : SortBool{} [predicate{}("Groups"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisGroups%r %c(%r %1 %c)%r"), function{}()] + symbol LblisIOError{}(SortK{}) : SortBool{} [predicate{}("IOError"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisIOError%r %c(%r %1 %c)%r"), function{}()] + symbol LblisIOFile{}(SortK{}) : SortBool{} [predicate{}("IOFile"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisIOFile%r %c(%r %1 %c)%r"), function{}()] + symbol LblisIOInt{}(SortK{}) : SortBool{} [predicate{}("IOInt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisIOInt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisIOString{}(SortK{}) : SortBool{} [predicate{}("IOString"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisIOString%r %c(%r %1 %c)%r"), function{}()] + symbol LblisId{}(SortK{}) : SortBool{} [predicate{}("Id"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisId%r %c(%r %1 %c)%r"), function{}()] + symbol LblisInputGroup{}(SortK{}) : SortBool{} [predicate{}("InputGroup"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisInputGroup%r %c(%r %1 %c)%r"), function{}()] + symbol LblisInputstackCell{}(SortK{}) : SortBool{} [predicate{}("InputstackCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisInputstackCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisInputstackCellOpt{}(SortK{}) : SortBool{} [predicate{}("InputstackCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisInputstackCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisInstruction{}(SortK{}) : SortBool{} [predicate{}("Instruction"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisInstruction%r %c(%r %1 %c)%r"), function{}()] + symbol LblisInt{}(SortK{}) : SortBool{} [predicate{}("Int"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisInt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisInternalStack{}(SortK{}) : SortBool{} [predicate{}("InternalStack"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisInternalStack%r %c(%r %1 %c)%r"), function{}()] + symbol LblisInvariant{}(SortK{}) : SortBool{} [predicate{}("Invariant"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisInvariant%r %c(%r %1 %c)%r"), function{}()] + symbol LblisInvariantsGroup{}(SortK{}) : SortBool{} [predicate{}("InvariantsGroup"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisInvariantsGroup%r %c(%r %1 %c)%r"), function{}()] + symbol LblisInvsCell{}(SortK{}) : SortBool{} [predicate{}("InvsCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisInvsCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisInvsCellOpt{}(SortK{}) : SortBool{} [predicate{}("InvsCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisInvsCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisK{}(SortK{}) : SortBool{} [predicate{}("K"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisK%r %c(%r %1 %c)%r"), function{}()] + symbol LblisKCell{}(SortK{}) : SortBool{} [predicate{}("KCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisKCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisKCellOpt{}(SortK{}) : SortBool{} [predicate{}("KCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisKCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisKConfigVar{}(SortK{}) : SortBool{} [predicate{}("KConfigVar"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisKConfigVar%r %c(%r %1 %c)%r"), function{}()] + symbol LblisKItem{}(SortK{}) : SortBool{} [predicate{}("KItem"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisKItem%r %c(%r %1 %c)%r"), function{}()] + symbol LblisKResult{}(SortK{}) : SortBool{} [predicate{}("KResult"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisKResult%r %c(%r %1 %c)%r"), function{}()] + symbol LblisKey{}(SortK{}) : SortBool{} [predicate{}("Key"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisKey%r %c(%r %1 %c)%r"), function{}()] + symbol LblisKeyHash{}(SortK{}) : SortBool{} [predicate{}("KeyHash"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisKeyHash%r %c(%r %1 %c)%r"), function{}()] + symbol LblisKnownaddrsCell{}(SortK{}) : SortBool{} [predicate{}("KnownaddrsCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisKnownaddrsCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisKnownaddrsCellOpt{}(SortK{}) : SortBool{} [predicate{}("KnownaddrsCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisKnownaddrsCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisLambdaData{}(SortK{}) : SortBool{} [predicate{}("LambdaData"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisLambdaData%r %c(%r %1 %c)%r"), function{}()] + symbol LblisList{}(SortK{}) : SortBool{} [predicate{}("List"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisList%r %c(%r %1 %c)%r"), function{}()] + symbol LblisLiteralStack{}(SortK{}) : SortBool{} [predicate{}("LiteralStack"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisLiteralStack%r %c(%r %1 %c)%r"), function{}()] + symbol LblisMBytes{}(SortK{}) : SortBool{} [predicate{}("MBytes"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisMBytes%r %c(%r %1 %c)%r"), function{}()] + symbol LblisMBytesLiteral{}(SortK{}) : SortBool{} [predicate{}("MBytesLiteral"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisMBytesLiteral%r %c(%r %1 %c)%r"), function{}()] + symbol LblisMap{}(SortK{}) : SortBool{} [predicate{}("Map"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisMap%r %c(%r %1 %c)%r"), function{}()] + symbol LblisMapEntry{}(SortK{}) : SortBool{} [predicate{}("MapEntry"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisMapEntry%r %c(%r %1 %c)%r"), function{}()] + symbol LblisMapEntryList{}(SortK{}) : SortBool{} [predicate{}("MapEntryList"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisMapEntryList%r %c(%r %1 %c)%r"), function{}()] + symbol LblisMapLiteral{}(SortK{}) : SortBool{} [predicate{}("MapLiteral"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisMapLiteral%r %c(%r %1 %c)%r"), function{}()] + symbol LblisMapOpInfo{}(SortK{}) : SortBool{} [predicate{}("MapOpInfo"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisMapOpInfo%r %c(%r %1 %c)%r"), function{}()] + symbol LblisMapTypeName{}(SortK{}) : SortBool{} [predicate{}("MapTypeName"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisMapTypeName%r %c(%r %1 %c)%r"), function{}()] + symbol LblisMaybeTypeName{}(SortK{}) : SortBool{} [predicate{}("MaybeTypeName"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisMaybeTypeName%r %c(%r %1 %c)%r"), function{}()] + symbol LblisMichelsonBool{}(SortK{}) : SortBool{} [predicate{}("MichelsonBool"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisMichelsonBool%r %c(%r %1 %c)%r"), function{}()] + symbol LblisMichelsonTopCell{}(SortK{}) : SortBool{} [predicate{}("MichelsonTopCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisMichelsonTopCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisMichelsonTopCellFragment{}(SortK{}) : SortBool{} [predicate{}("MichelsonTopCellFragment"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisMichelsonTopCellFragment%r %c(%r %1 %c)%r"), function{}()] + symbol LblisMichelsonTopCellOpt{}(SortK{}) : SortBool{} [predicate{}("MichelsonTopCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisMichelsonTopCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisMutez{}(SortK{}) : SortBool{} [predicate{}("Mutez"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisMutez%r %c(%r %1 %c)%r"), function{}()] + symbol LblisMyaddrCell{}(SortK{}) : SortBool{} [predicate{}("MyaddrCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisMyaddrCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisMyaddrCellOpt{}(SortK{}) : SortBool{} [predicate{}("MyaddrCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisMyaddrCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisMyamountCell{}(SortK{}) : SortBool{} [predicate{}("MyamountCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisMyamountCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisMyamountCellOpt{}(SortK{}) : SortBool{} [predicate{}("MyamountCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisMyamountCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisMybalanceCell{}(SortK{}) : SortBool{} [predicate{}("MybalanceCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisMybalanceCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisMybalanceCellOpt{}(SortK{}) : SortBool{} [predicate{}("MybalanceCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisMybalanceCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisMychainidCell{}(SortK{}) : SortBool{} [predicate{}("MychainidCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisMychainidCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisMychainidCellOpt{}(SortK{}) : SortBool{} [predicate{}("MychainidCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisMychainidCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisMynowCell{}(SortK{}) : SortBool{} [predicate{}("MynowCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisMynowCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisMynowCellOpt{}(SortK{}) : SortBool{} [predicate{}("MynowCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisMynowCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisNonceCell{}(SortK{}) : SortBool{} [predicate{}("NonceCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisNonceCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisNonceCellOpt{}(SortK{}) : SortBool{} [predicate{}("NonceCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisNonceCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisNowGroup{}(SortK{}) : SortBool{} [predicate{}("NowGroup"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisNowGroup%r %c(%r %1 %c)%r"), function{}()] + symbol LblisNullaryTypeName{}(SortK{}) : SortBool{} [predicate{}("NullaryTypeName"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisNullaryTypeName%r %c(%r %1 %c)%r"), function{}()] + symbol LblisNumTypeName{}(SortK{}) : SortBool{} [predicate{}("NumTypeName"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisNumTypeName%r %c(%r %1 %c)%r"), function{}()] + symbol LblisOperationNonce{}(SortK{}) : SortBool{} [predicate{}("OperationNonce"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisOperationNonce%r %c(%r %1 %c)%r"), function{}()] + symbol LblisOptionData{}(SortK{}) : SortBool{} [predicate{}("OptionData"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisOptionData%r %c(%r %1 %c)%r"), function{}()] + symbol LblisOrData{}(SortK{}) : SortBool{} [predicate{}("OrData"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisOrData%r %c(%r %1 %c)%r"), function{}()] + symbol LblisOtherContractsMapEntry{}(SortK{}) : SortBool{} [predicate{}("OtherContractsMapEntry"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisOtherContractsMapEntry%r %c(%r %1 %c)%r"), function{}()] + symbol LblisOtherContractsMapEntryList{}(SortK{}) : SortBool{} [predicate{}("OtherContractsMapEntryList"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisOtherContractsMapEntryList%r %c(%r %1 %c)%r"), function{}()] + symbol LblisOutputGroup{}(SortK{}) : SortBool{} [predicate{}("OutputGroup"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisOutputGroup%r %c(%r %1 %c)%r"), function{}()] + symbol LblisOutputStack{}(SortK{}) : SortBool{} [predicate{}("OutputStack"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisOutputStack%r %c(%r %1 %c)%r"), function{}()] + symbol LblisPair{}(SortK{}) : SortBool{} [predicate{}("Pair"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisPair%r %c(%r %1 %c)%r"), function{}()] + symbol LblisParameterDecl{}(SortK{}) : SortBool{} [predicate{}("ParameterDecl"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisParameterDecl%r %c(%r %1 %c)%r"), function{}()] + symbol LblisParameterGroup{}(SortK{}) : SortBool{} [predicate{}("ParameterGroup"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisParameterGroup%r %c(%r %1 %c)%r"), function{}()] + symbol LblisParameterValueGroup{}(SortK{}) : SortBool{} [predicate{}("ParameterValueGroup"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisParameterValueGroup%r %c(%r %1 %c)%r"), function{}()] + symbol LblisParamtypeCell{}(SortK{}) : SortBool{} [predicate{}("ParamtypeCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisParamtypeCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisParamtypeCellOpt{}(SortK{}) : SortBool{} [predicate{}("ParamtypeCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisParamtypeCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisParamvalueCell{}(SortK{}) : SortBool{} [predicate{}("ParamvalueCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisParamvalueCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisParamvalueCellOpt{}(SortK{}) : SortBool{} [predicate{}("ParamvalueCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisParamvalueCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisPgm{}(SortK{}) : SortBool{} [predicate{}("Pgm"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisPgm%r %c(%r %1 %c)%r"), function{}()] + symbol LblisPostCell{}(SortK{}) : SortBool{} [predicate{}("PostCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisPostCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisPostCellOpt{}(SortK{}) : SortBool{} [predicate{}("PostCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisPostCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisPostconditionGroup{}(SortK{}) : SortBool{} [predicate{}("PostconditionGroup"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisPostconditionGroup%r %c(%r %1 %c)%r"), function{}()] + symbol LblisPreCell{}(SortK{}) : SortBool{} [predicate{}("PreCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisPreCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisPreCellOpt{}(SortK{}) : SortBool{} [predicate{}("PreCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisPreCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisPreData{}(SortK{}) : SortBool{} [predicate{}("PreData"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisPreData%r %c(%r %1 %c)%r"), function{}()] + symbol LblisPreType{}(SortK{}) : SortBool{} [predicate{}("PreType"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisPreType%r %c(%r %1 %c)%r"), function{}()] + symbol LblisPreconditionGroup{}(SortK{}) : SortBool{} [predicate{}("PreconditionGroup"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisPreconditionGroup%r %c(%r %1 %c)%r"), function{}()] + symbol LblisReturncodeCell{}(SortK{}) : SortBool{} [predicate{}("ReturncodeCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisReturncodeCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisReturncodeCellOpt{}(SortK{}) : SortBool{} [predicate{}("ReturncodeCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisReturncodeCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisScriptCell{}(SortK{}) : SortBool{} [predicate{}("ScriptCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisScriptCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisScriptCellOpt{}(SortK{}) : SortBool{} [predicate{}("ScriptCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisScriptCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisSelfGroup{}(SortK{}) : SortBool{} [predicate{}("SelfGroup"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisSelfGroup%r %c(%r %1 %c)%r"), function{}()] + symbol LblisSenderGroup{}(SortK{}) : SortBool{} [predicate{}("SenderGroup"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisSenderGroup%r %c(%r %1 %c)%r"), function{}()] + symbol LblisSenderaddrCell{}(SortK{}) : SortBool{} [predicate{}("SenderaddrCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisSenderaddrCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisSenderaddrCellOpt{}(SortK{}) : SortBool{} [predicate{}("SenderaddrCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisSenderaddrCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisSequenceData{}(SortK{}) : SortBool{} [predicate{}("SequenceData"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisSequenceData%r %c(%r %1 %c)%r"), function{}()] + symbol LblisSet{}(SortK{}) : SortBool{} [predicate{}("Set"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisSet%r %c(%r %1 %c)%r"), function{}()] + symbol LblisSignature{}(SortK{}) : SortBool{} [predicate{}("Signature"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisSignature%r %c(%r %1 %c)%r"), function{}()] + symbol LblisSignedness{}(SortK{}) : SortBool{} [predicate{}("Signedness"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisSignedness%r %c(%r %1 %c)%r"), function{}()] + symbol LblisSimpleData{}(SortK{}) : SortBool{} [predicate{}("SimpleData"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisSimpleData%r %c(%r %1 %c)%r"), function{}()] + symbol LblisSimpleType{}(SortK{}) : SortBool{} [predicate{}("SimpleType"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisSimpleType%r %c(%r %1 %c)%r"), function{}()] + symbol LblisSourceGroup{}(SortK{}) : SortBool{} [predicate{}("SourceGroup"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisSourceGroup%r %c(%r %1 %c)%r"), function{}()] + symbol LblisSourceaddrCell{}(SortK{}) : SortBool{} [predicate{}("SourceaddrCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisSourceaddrCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisSourceaddrCellOpt{}(SortK{}) : SortBool{} [predicate{}("SourceaddrCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisSourceaddrCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisStack{}(SortK{}) : SortBool{} [predicate{}("Stack"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisStack%r %c(%r %1 %c)%r"), function{}()] + symbol LblisStackCell{}(SortK{}) : SortBool{} [predicate{}("StackCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisStackCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisStackCellOpt{}(SortK{}) : SortBool{} [predicate{}("StackCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisStackCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisStackElement{}(SortK{}) : SortBool{} [predicate{}("StackElement"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisStackElement%r %c(%r %1 %c)%r"), function{}()] + symbol LblisStackElementList{}(SortK{}) : SortBool{} [predicate{}("StackElementList"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisStackElementList%r %c(%r %1 %c)%r"), function{}()] + symbol LblisStackElementLiteral{}(SortK{}) : SortBool{} [predicate{}("StackElementLiteral"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisStackElementLiteral%r %c(%r %1 %c)%r"), function{}()] + symbol LblisStorageDecl{}(SortK{}) : SortBool{} [predicate{}("StorageDecl"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisStorageDecl%r %c(%r %1 %c)%r"), function{}()] + symbol LblisStorageValueGroup{}(SortK{}) : SortBool{} [predicate{}("StorageValueGroup"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisStorageValueGroup%r %c(%r %1 %c)%r"), function{}()] + symbol LblisStoragetypeCell{}(SortK{}) : SortBool{} [predicate{}("StoragetypeCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisStoragetypeCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisStoragetypeCellOpt{}(SortK{}) : SortBool{} [predicate{}("StoragetypeCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisStoragetypeCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisStoragevalueCell{}(SortK{}) : SortBool{} [predicate{}("StoragevalueCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisStoragevalueCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisStoragevalueCellOpt{}(SortK{}) : SortBool{} [predicate{}("StoragevalueCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisStoragevalueCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisStream{}(SortK{}) : SortBool{} [predicate{}("Stream"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisStream%r %c(%r %1 %c)%r"), function{}()] + symbol LblisString{}(SortK{}) : SortBool{} [predicate{}("String"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisString%r %c(%r %1 %c)%r"), function{}()] + symbol LblisSymbolicData{}(SortK{}) : SortBool{} [predicate{}("SymbolicData"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisSymbolicData%r %c(%r %1 %c)%r"), function{}()] + symbol LblisSymbolicElement{}(SortK{}) : SortBool{} [predicate{}("SymbolicElement"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisSymbolicElement%r %c(%r %1 %c)%r"), function{}()] + symbol LblisSymbolsCell{}(SortK{}) : SortBool{} [predicate{}("SymbolsCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisSymbolsCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisSymbolsCellOpt{}(SortK{}) : SortBool{} [predicate{}("SymbolsCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisSymbolsCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisTimestamp{}(SortK{}) : SortBool{} [predicate{}("Timestamp"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisTimestamp%r %c(%r %1 %c)%r"), function{}()] + symbol LblisTraceCell{}(SortK{}) : SortBool{} [predicate{}("TraceCell"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisTraceCell%r %c(%r %1 %c)%r"), function{}()] + symbol LblisTraceCellOpt{}(SortK{}) : SortBool{} [predicate{}("TraceCellOpt"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisTraceCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol LblisType{}(SortK{}) : SortBool{} [predicate{}("Type"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisType%r %c(%r %1 %c)%r"), function{}()] + symbol LblisTypeAnnotation{}(SortK{}) : SortBool{} [predicate{}("TypeAnnotation"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisTypeAnnotation%r %c(%r %1 %c)%r"), function{}()] + symbol LblisTypeName{}(SortK{}) : SortBool{} [predicate{}("TypeName"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisTypeName%r %c(%r %1 %c)%r"), function{}()] + symbol LblisTypedData{}(SortK{}) : SortBool{} [predicate{}("TypedData"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisTypedData%r %c(%r %1 %c)%r"), function{}()] + symbol LblisTypedSymbol{}(SortK{}) : SortBool{} [predicate{}("TypedSymbol"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisTypedSymbol%r %c(%r %1 %c)%r"), function{}()] + symbol LblisUnaryTypeName{}(SortK{}) : SortBool{} [predicate{}("UnaryTypeName"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisUnaryTypeName%r %c(%r %1 %c)%r"), function{}()] + symbol LblisUnificationFailure{}(SortK{}) : SortBool{} [predicate{}("UnificationFailure"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisUnificationFailure%r %c(%r %1 %c)%r"), function{}()] + symbol LblisUnifiedList{}(SortK{}) : SortBool{} [predicate{}("UnifiedList"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisUnifiedList%r %c(%r %1 %c)%r"), function{}()] + symbol LblisUnifiedSet{}(SortK{}) : SortBool{} [predicate{}("UnifiedSet"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisUnifiedSet%r %c(%r %1 %c)%r"), function{}()] + symbol LblisValue'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'Data{}(SortData{}) : SortBool{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("isValue"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2263,19,2263,54)"), left{}(), format{}("%cisValue%r %c(%r %1 %c)%r"), function{}()] + symbol LblisValue'LParUndsCommUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName'Unds'Data{}(SortTypeName{}, SortData{}) : SortBool{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("isValue"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2273,19,2273,64)"), left{}(), format{}("%cisValue%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + symbol LblisVariableAnnotation{}(SortK{}) : SortBool{} [predicate{}("VariableAnnotation"), priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cisVariableAnnotation%r %c(%r %1 %c)%r"), function{}()] + symbol Lblkey'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}() : SortNullaryTypeName{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(169,30,169,34)"), left{}(), format{}("%ckey%r"), injective{}()] + symbol Lblkey'Unds'hash'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}() : SortNullaryTypeName{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(166,30,166,39)"), left{}(), format{}("%ckey_hash%r"), injective{}()] + hooked-symbol Lblkeys'LParUndsRParUnds'MAP'Unds'Set'Unds'Map{}(SortMap{}) : SortSet{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("keys"), hook{}("MAP.keys"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(342,18,342,86)"), left{}(), format{}("%ckeys%r %c(%r %1 %c)%r"), function{}()] + hooked-symbol Lblkeys'Unds'list'LParUndsRParUnds'MAP'Unds'List'Unds'Map{}(SortMap{}) : SortList{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), hook{}("MAP.keys_list"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(350,19,350,79)"), left{}(), format{}("%ckeys_list%r %c(%r %1 %c)%r"), function{}()] + symbol Lbllambda'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}() : SortBinaryTypeName{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(184,30,184,37)"), left{}(), format{}("%clambda%r"), injective{}()] + hooked-symbol LbllengthBytes'LParUndsRParUnds'BYTES-HOOKED'Unds'Int'Unds'Bytes{}(SortBytes{}) : SortInt{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), smtlib{}("lengthBytes"), terminals{}("1101"), klabel{}("lengthBytes"), hook{}("BYTES.length"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1752,18,1752,99)"), left{}(), format{}("%clengthBytes%r %c(%r %1 %c)%r"), function{}()] + hooked-symbol LbllengthString'LParUndsRParUnds'STRING-COMMON'Unds'Int'Unds'String{}(SortString{}) : SortInt{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("lengthString"), hook{}("STRING.length"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1355,18,1355,84)"), left{}(), format{}("%clengthString%r %c(%r %1 %c)%r"), function{}()] + symbol Lbllist'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}() : SortUnaryTypeName{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(176,30,176,35)"), left{}(), format{}("%clist%r"), injective{}()] + symbol LbllittleEndianBytes{}() : SortEndianness{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("littleEndianBytes"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1625,25,1625,64)"), left{}(), format{}("%cLE%r"), injective{}()] + hooked-symbol Lbllog2Int'LParUndsRParUnds'INT-COMMON'Unds'Int'Unds'Int{}(SortInt{}) : SortInt{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("log2Int"), hook{}("INT.log2"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(939,18,939,74)"), left{}(), format{}("%clog2Int%r %c(%r %1 %c)%r"), function{}()] + hooked-symbol LblmakeList'LParUndsCommUndsRParUnds'LIST'Unds'List'Unds'Int'Unds'KItem{}(SortInt{}, SortKItem{}) : SortList{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("makeList"), hook{}("LIST.make"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(656,19,656,81)"), left{}(), format{}("%cmakeList%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + symbol Lblmap'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}() : SortMapTypeName{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(180,26,180,30)"), left{}(), format{}("%cmap%r"), injective{}()] + hooked-symbol LblmaxInt'LParUndsCommUndsRParUnds'INT-COMMON'Unds'Int'Unds'Int'Unds'Int{}(SortInt{}, SortInt{}) : SortInt{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), smt-hook{}("(ite (< #1 #2) #2 #1)"), right{}(), terminals{}("110101"), hook{}("INT.max"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(920,18,920,118)"), left{}(), format{}("%cmaxInt%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + hooked-symbol LblminInt'LParUndsCommUndsRParUnds'INT-COMMON'Unds'Int'Unds'Int'Unds'Int{}(SortInt{}, SortInt{}) : SortInt{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), smt-hook{}("(ite (< #1 #2) #1 #2)"), right{}(), terminals{}("110101"), hook{}("INT.min"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(919,18,919,118)"), left{}(), format{}("%cminInt%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + symbol Lblmutez'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}() : SortNullaryTypeName{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(164,30,164,36)"), left{}(), format{}("%cmutez%r"), injective{}()] + symbol Lblnat'Unds'MICHELSON-COMMON-SYNTAX'Unds'NumTypeName{}() : SortNumTypeName{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(159,34,159,38)"), left{}(), format{}("%cnat%r"), injective{}()] + hooked-symbol LblnewUUID'Unds'STRING-COMMON'Unds'String{}() : SortString{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1"), impure{}(), hook{}("STRING.uuid"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1487,21,1487,67)"), left{}(), format{}("%cnewUUID%r"), function{}()] + symbol LblnoAssumeFailedCell{}() : SortAssumeFailedCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("AssumeFailedCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoAssumeFailedCell%r"), injective{}()] + symbol LblnoBigmapsCell{}() : SortBigmapsCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("BigmapsCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoBigmapsCell%r"), injective{}()] + symbol LblnoCutpointsCell{}() : SortCutpointsCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("CutpointsCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoCutpointsCell%r"), injective{}()] + symbol LblnoExpectedCell{}() : SortExpectedCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("ExpectedCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoExpectedCell%r"), injective{}()] + symbol LblnoGeneratedCounterCell{}() : SortGeneratedCounterCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("GeneratedCounterCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoGeneratedCounterCell%r"), injective{}()] + symbol LblnoInputstackCell{}() : SortInputstackCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("InputstackCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoInputstackCell%r"), injective{}()] + symbol LblnoInvsCell{}() : SortInvsCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("InvsCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoInvsCell%r"), injective{}()] + symbol LblnoKCell{}() : SortKCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("KCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoKCell%r"), injective{}()] + symbol LblnoKnownaddrsCell{}() : SortKnownaddrsCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("KnownaddrsCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoKnownaddrsCell%r"), injective{}()] + symbol LblnoMichelsonTopCell{}() : SortMichelsonTopCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("MichelsonTopCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoMichelsonTopCell%r"), injective{}()] + symbol LblnoMyaddrCell{}() : SortMyaddrCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("MyaddrCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoMyaddrCell%r"), injective{}()] + symbol LblnoMyamountCell{}() : SortMyamountCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("MyamountCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoMyamountCell%r"), injective{}()] + symbol LblnoMybalanceCell{}() : SortMybalanceCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("MybalanceCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoMybalanceCell%r"), injective{}()] + symbol LblnoMychainidCell{}() : SortMychainidCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("MychainidCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoMychainidCell%r"), injective{}()] + symbol LblnoMynowCell{}() : SortMynowCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("MynowCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoMynowCell%r"), injective{}()] + symbol LblnoNonceCell{}() : SortNonceCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("NonceCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoNonceCell%r"), injective{}()] + symbol LblnoParamtypeCell{}() : SortParamtypeCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("ParamtypeCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoParamtypeCell%r"), injective{}()] + symbol LblnoParamvalueCell{}() : SortParamvalueCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("ParamvalueCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoParamvalueCell%r"), injective{}()] + symbol LblnoPostCell{}() : SortPostCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("PostCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoPostCell%r"), injective{}()] + symbol LblnoPreCell{}() : SortPreCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("PreCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoPreCell%r"), injective{}()] + symbol LblnoReturncodeCell{}() : SortReturncodeCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("ReturncodeCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoReturncodeCell%r"), injective{}()] + symbol LblnoScriptCell{}() : SortScriptCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("ScriptCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoScriptCell%r"), injective{}()] + symbol LblnoSenderaddrCell{}() : SortSenderaddrCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("SenderaddrCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoSenderaddrCell%r"), injective{}()] + symbol LblnoSourceaddrCell{}() : SortSourceaddrCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("SourceaddrCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoSourceaddrCell%r"), injective{}()] + symbol LblnoStackCell{}() : SortStackCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("StackCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoStackCell%r"), injective{}()] + symbol LblnoStoragetypeCell{}() : SortStoragetypeCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("StoragetypeCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoStoragetypeCell%r"), injective{}()] + symbol LblnoStoragevalueCell{}() : SortStoragevalueCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("StoragevalueCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoStoragevalueCell%r"), injective{}()] + symbol LblnoSymbolsCell{}() : SortSymbolsCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("SymbolsCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoSymbolsCell%r"), injective{}()] + symbol LblnoTraceCell{}() : SortTraceCellOpt{} [functional{}(), constructor{}(), cellOptAbsent{}("TraceCell"), priorities{}(), right{}(), terminals{}("1"), left{}(), format{}("%cnoTraceCell%r"), injective{}()] + hooked-symbol LblnotBool'Unds'{}(SortBool{}) : SortBool{} [latex{}("\\neg_{\\scriptstyle\\it Bool}{#1}"), functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(Lbl'Unds'orElseBool'Unds'{}(),Lbl'UndsEqlsSlshEqls'Bool'Unds'{}(),Lbl'Unds'andThenBool'Unds'{}(),Lbl'Unds'impliesBool'Unds'{}(),Lbl'UndsEqlsEqls'Bool'Unds'{}(),Lbl'Unds'andBool'Unds'{}(),Lbl'Unds'xorBool'Unds'{}(),Lbl'Unds'orBool'UndsUnds'BOOL'Unds'Bool'Unds'Bool'Unds'Bool{}()), smt-hook{}("not"), boolOperation{}(), right{}(), terminals{}("10"), klabel{}("notBool_"), hook{}("BOOL.not"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(778,19,778,176)"), left{}(), format{}("%cnotBool%r %1"), function{}()] + symbol Lblnow'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'NowGroup'Unds'Int{}(SortInt{}) : SortNowGroup{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(355,23,355,31)"), left{}(), format{}("%cnow%r %1"), injective{}()] + symbol Lbloperation'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}() : SortNullaryTypeName{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(172,30,172,40)"), left{}(), format{}("%coperation%r"), injective{}()] + symbol Lbloption'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}() : SortUnaryTypeName{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(175,30,175,37)"), left{}(), format{}("%coption%r"), injective{}()] + symbol Lblor'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}() : SortBinaryTypeName{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(183,30,183,33)"), left{}(), format{}("%cor%r"), injective{}()] + hooked-symbol LblordChar'LParUndsRParUnds'STRING-COMMON'Unds'Int'Unds'String{}(SortString{}) : SortInt{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("ordChar"), hook{}("STRING.ord"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1365,18,1365,69)"), left{}(), format{}("%cordChar%r %c(%r %1 %c)%r"), function{}()] + symbol Lblother'Unds'contracts'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'ContractsGroup'Unds'OtherContractsMapEntryList{}(SortOtherContractsMapEntryList{}) : SortContractsGroup{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(362,29,362,80)"), left{}(), format{}("%cother_contracts%r %c{%r %1 %c}%r"), injective{}()] + symbol Lbloutput'UndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'OutputGroup'Unds'OutputStack{}(SortOutputStack{}) : SortOutputGroup{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(697,26,697,45)"), left{}(), format{}("%coutput%r %1"), injective{}()] + hooked-symbol LblpadLeftBytes'LParUndsCommUndsCommUndsRParUnds'BYTES-HOOKED'Unds'Bytes'Unds'Bytes'Unds'Int'Unds'Int{}(SortBytes{}, SortInt{}, SortInt{}) : SortBytes{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("11010101"), klabel{}("padLeftBytes"), hook{}("BYTES.padLeft"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1735,20,1735,95)"), left{}(), format{}("%cpadLeftBytes%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), function{}()] + hooked-symbol LblpadRightBytes'LParUndsCommUndsCommUndsRParUnds'BYTES-HOOKED'Unds'Bytes'Unds'Bytes'Unds'Int'Unds'Int{}(SortBytes{}, SortInt{}, SortInt{}) : SortBytes{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("11010101"), klabel{}("padRightBytes"), hook{}("BYTES.padRight"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1734,20,1734,97)"), left{}(), format{}("%cpadRightBytes%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), function{}()] + symbol Lblpair'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}() : SortBinaryTypeName{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(182,30,182,35)"), left{}(), format{}("%cpair%r"), injective{}()] + symbol Lblparameter'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'ParameterDecl'Unds'Type{}(SortType{}) : SortParameterDecl{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(301,28,301,43)"), left{}(), format{}("%cparameter%r %1"), injective{}()] + symbol Lblparameter'Unds'value'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'ParameterValueGroup'Unds'Data{}(SortData{}) : SortParameterValueGroup{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(363,34,363,55)"), left{}(), format{}("%cparameter_value%r %1"), injective{}()] + symbol Lblpostcondition'LBraUndsRBraUnds'SYMBOLIC-UNIT-TEST-COMMON-SYNTAX'Unds'PostconditionGroup'Unds'BlockList{}(SortBlockList{}) : SortPostconditionGroup{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(749,33,749,65)"), left{}(), format{}("%cpostcondition%r %c{%r %1 %c}%r"), injective{}()] + symbol Lblprecondition'LBraUndsRBraUnds'SYMBOLIC-UNIT-TEST-COMMON-SYNTAX'Unds'PreconditionGroup'Unds'BlockList{}(SortBlockList{}) : SortPreconditionGroup{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(748,32,748,63)"), left{}(), format{}("%cprecondition%r %c{%r %1 %c}%r"), injective{}()] + symbol Lblproject'ColnHash'MapOpInfo'LParUndsCommUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'MapOpInfo'Unds'TypeName'Unds'TypeName'Unds'MaybeTypeName'Unds'Map'Unds'Map'Unds'Block'Coln'keyType{}(SortMapOpInfo{}) : SortTypeName{} [priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%ckeyType%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'ColnHash'MapOpInfo'LParUndsCommUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'MapOpInfo'Unds'TypeName'Unds'TypeName'Unds'MaybeTypeName'Unds'Map'Unds'Map'Unds'Block'Coln'mapBody{}(SortMapOpInfo{}) : SortBlock{} [priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cmapBody%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'ColnHash'MapOpInfo'LParUndsCommUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'MapOpInfo'Unds'TypeName'Unds'TypeName'Unds'MaybeTypeName'Unds'Map'Unds'Map'Unds'Block'Coln'newMap{}(SortMapOpInfo{}) : SortMap{} [priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cnewMap%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'ColnHash'MapOpInfo'LParUndsCommUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'MapOpInfo'Unds'TypeName'Unds'TypeName'Unds'MaybeTypeName'Unds'Map'Unds'Map'Unds'Block'Coln'newValType{}(SortMapOpInfo{}) : SortMaybeTypeName{} [priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cnewValType%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'ColnHash'MapOpInfo'LParUndsCommUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'MapOpInfo'Unds'TypeName'Unds'TypeName'Unds'MaybeTypeName'Unds'Map'Unds'Map'Unds'Block'Coln'origMap{}(SortMapOpInfo{}) : SortMap{} [priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%corigMap%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'ColnHash'MapOpInfo'LParUndsCommUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'MapOpInfo'Unds'TypeName'Unds'TypeName'Unds'MaybeTypeName'Unds'Map'Unds'Map'Unds'Block'Coln'origValType{}(SortMapOpInfo{}) : SortTypeName{} [priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%corigValType%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'ColnHash'tempFile'Coln'fd{}(SortIOFile{}) : SortInt{} [priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cfd%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'ColnHash'tempFile'Coln'path{}(SortIOFile{}) : SortString{} [priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cpath%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'ColnHash'unknownIOError'Coln'errno{}(SortIOError{}) : SortInt{} [priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cerrno%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Aborted'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Error'Unds'String'Unds'KItem'Unds'K'Unds'K'Coln'message{}(SortError{}) : SortString{} [priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cmessage%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Aborted'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Error'Unds'String'Unds'KItem'Unds'K'Unds'K'Coln'restOfContinuation{}(SortError{}) : SortK{} [priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%crestOfContinuation%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Aborted'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Error'Unds'String'Unds'KItem'Unds'K'Unds'K'Coln'restOfStack{}(SortError{}) : SortK{} [priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%crestOfStack%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Aborted'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Error'Unds'String'Unds'KItem'Unds'K'Unds'K'Coln'stackTop{}(SortError{}) : SortKItem{} [priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cstackTop%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Address{}(SortK{}) : SortAddress{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Address%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'AmountGroup{}(SortK{}) : SortAmountGroup{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:AmountGroup%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Annotation{}(SortK{}) : SortAnnotation{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Annotation%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'AnnotationList{}(SortK{}) : SortAnnotationList{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:AnnotationList%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'AssumeFailedCell{}(SortK{}) : SortAssumeFailedCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:AssumeFailedCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'AssumeFailedCellOpt{}(SortK{}) : SortAssumeFailedCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:AssumeFailedCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'BalanceGroup{}(SortK{}) : SortBalanceGroup{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:BalanceGroup%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'BigMapEntry{}(SortK{}) : SortBigMapEntry{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:BigMapEntry%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'BigMapEntryList{}(SortK{}) : SortBigMapEntryList{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:BigMapEntryList%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'BigMapGroup{}(SortK{}) : SortBigMapGroup{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:BigMapGroup%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'BigmapsCell{}(SortK{}) : SortBigmapsCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:BigmapsCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'BigmapsCellOpt{}(SortK{}) : SortBigmapsCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:BigmapsCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'BinaryTypeName{}(SortK{}) : SortBinaryTypeName{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:BinaryTypeName%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Block{}(SortK{}) : SortBlock{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Block%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'BlockList{}(SortK{}) : SortBlockList{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:BlockList%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'BlockchainOperation{}(SortK{}) : SortBlockchainOperation{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:BlockchainOperation%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Bool{}(SortK{}) : SortBool{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Bool%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'BoolExp{}(SortK{}) : SortBoolExp{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:BoolExp%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Bytes{}(SortK{}) : SortBytes{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Bytes%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'CUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant'Coln'id{}(SortInstruction{}) : SortInt{} [priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cid%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'CUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant'Coln'invariant{}(SortInstruction{}) : SortInvariant{} [priorities{}(), right{}(), terminals{}("1101"), left{}(), format{}("%cinvariant%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Cell{}(SortK{}) : SortCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Cell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'ChainGroup{}(SortK{}) : SortChainGroup{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:ChainGroup%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'ChainId{}(SortK{}) : SortChainId{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:ChainId%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'CodeDecl{}(SortK{}) : SortCodeDecl{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:CodeDecl%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'CodeGroup{}(SortK{}) : SortCodeGroup{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:CodeGroup%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Contract{}(SortK{}) : SortContract{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Contract%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'ContractData{}(SortK{}) : SortContractData{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:ContractData%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'ContractGroup{}(SortK{}) : SortContractGroup{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:ContractGroup%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'ContractsGroup{}(SortK{}) : SortContractsGroup{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:ContractsGroup%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'CutpointsCell{}(SortK{}) : SortCutpointsCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:CutpointsCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'CutpointsCellOpt{}(SortK{}) : SortCutpointsCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:CutpointsCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Data{}(SortK{}) : SortData{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Data%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'DataList{}(SortK{}) : SortDataList{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:DataList%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'DataOrSeq{}(SortK{}) : SortDataOrSeq{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:DataOrSeq%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'EmptyBlock{}(SortK{}) : SortEmptyBlock{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:EmptyBlock%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Endianness{}(SortK{}) : SortEndianness{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Endianness%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Error{}(SortK{}) : SortError{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Error%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'ExpectedCell{}(SortK{}) : SortExpectedCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:ExpectedCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'ExpectedCellOpt{}(SortK{}) : SortExpectedCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:ExpectedCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'FailedStack{}(SortK{}) : SortFailedStack{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:FailedStack%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'FieldAnnotation{}(SortK{}) : SortFieldAnnotation{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:FieldAnnotation%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Float{}(SortK{}) : SortFloat{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Float%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'GeneratedCounterCell{}(SortK{}) : SortGeneratedCounterCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:GeneratedCounterCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'GeneratedCounterCellOpt{}(SortK{}) : SortGeneratedCounterCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:GeneratedCounterCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'GeneratedTopCell{}(SortK{}) : SortGeneratedTopCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:GeneratedTopCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'GeneratedTopCellFragment{}(SortK{}) : SortGeneratedTopCellFragment{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:GeneratedTopCellFragment%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Group{}(SortK{}) : SortGroup{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Group%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Groups{}(SortK{}) : SortGroups{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Groups%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'IOError{}(SortK{}) : SortIOError{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:IOError%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'IOFile{}(SortK{}) : SortIOFile{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:IOFile%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'IOInt{}(SortK{}) : SortIOInt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:IOInt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'IOString{}(SortK{}) : SortIOString{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:IOString%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Id{}(SortK{}) : SortId{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Id%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'InputGroup{}(SortK{}) : SortInputGroup{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:InputGroup%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'InputstackCell{}(SortK{}) : SortInputstackCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:InputstackCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'InputstackCellOpt{}(SortK{}) : SortInputstackCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:InputstackCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Instruction{}(SortK{}) : SortInstruction{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Instruction%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Int{}(SortK{}) : SortInt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Int%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'InternalStack{}(SortK{}) : SortInternalStack{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:InternalStack%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Invariant{}(SortK{}) : SortInvariant{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Invariant%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'InvariantsGroup{}(SortK{}) : SortInvariantsGroup{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:InvariantsGroup%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'InvsCell{}(SortK{}) : SortInvsCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:InvsCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'InvsCellOpt{}(SortK{}) : SortInvsCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:InvsCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'K{}(SortK{}) : SortK{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:K%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'KCell{}(SortK{}) : SortKCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:KCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'KCellOpt{}(SortK{}) : SortKCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:KCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'KItem{}(SortK{}) : SortKItem{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:KItem%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'KResult{}(SortK{}) : SortKResult{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:KResult%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Key{}(SortK{}) : SortKey{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Key%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'KeyHash{}(SortK{}) : SortKeyHash{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:KeyHash%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'KnownaddrsCell{}(SortK{}) : SortKnownaddrsCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:KnownaddrsCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'KnownaddrsCellOpt{}(SortK{}) : SortKnownaddrsCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:KnownaddrsCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'LambdaData{}(SortK{}) : SortLambdaData{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:LambdaData%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'List{}(SortK{}) : SortList{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:List%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'LiteralStack{}(SortK{}) : SortLiteralStack{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:LiteralStack%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'MBytes{}(SortK{}) : SortMBytes{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:MBytes%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'MBytesLiteral{}(SortK{}) : SortMBytesLiteral{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:MBytesLiteral%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Map{}(SortK{}) : SortMap{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Map%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'MapEntry{}(SortK{}) : SortMapEntry{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:MapEntry%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'MapEntryList{}(SortK{}) : SortMapEntryList{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:MapEntryList%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'MapLiteral{}(SortK{}) : SortMapLiteral{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:MapLiteral%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'MapOpInfo{}(SortK{}) : SortMapOpInfo{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:MapOpInfo%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'MapTypeName{}(SortK{}) : SortMapTypeName{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:MapTypeName%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'MaybeTypeName{}(SortK{}) : SortMaybeTypeName{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:MaybeTypeName%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'MichelsonBool{}(SortK{}) : SortMichelsonBool{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:MichelsonBool%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'MichelsonTopCell{}(SortK{}) : SortMichelsonTopCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:MichelsonTopCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'MichelsonTopCellFragment{}(SortK{}) : SortMichelsonTopCellFragment{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:MichelsonTopCellFragment%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'MichelsonTopCellOpt{}(SortK{}) : SortMichelsonTopCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:MichelsonTopCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Mutez{}(SortK{}) : SortMutez{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Mutez%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'MyaddrCell{}(SortK{}) : SortMyaddrCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:MyaddrCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'MyaddrCellOpt{}(SortK{}) : SortMyaddrCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:MyaddrCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'MyamountCell{}(SortK{}) : SortMyamountCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:MyamountCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'MyamountCellOpt{}(SortK{}) : SortMyamountCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:MyamountCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'MybalanceCell{}(SortK{}) : SortMybalanceCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:MybalanceCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'MybalanceCellOpt{}(SortK{}) : SortMybalanceCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:MybalanceCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'MychainidCell{}(SortK{}) : SortMychainidCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:MychainidCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'MychainidCellOpt{}(SortK{}) : SortMychainidCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:MychainidCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'MynowCell{}(SortK{}) : SortMynowCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:MynowCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'MynowCellOpt{}(SortK{}) : SortMynowCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:MynowCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'NonceCell{}(SortK{}) : SortNonceCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:NonceCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'NonceCellOpt{}(SortK{}) : SortNonceCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:NonceCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'NowGroup{}(SortK{}) : SortNowGroup{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:NowGroup%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'NullaryTypeName{}(SortK{}) : SortNullaryTypeName{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:NullaryTypeName%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'NumTypeName{}(SortK{}) : SortNumTypeName{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:NumTypeName%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'OperationNonce{}(SortK{}) : SortOperationNonce{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:OperationNonce%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'OptionData{}(SortK{}) : SortOptionData{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:OptionData%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'OrData{}(SortK{}) : SortOrData{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:OrData%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'OtherContractsMapEntry{}(SortK{}) : SortOtherContractsMapEntry{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:OtherContractsMapEntry%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'OtherContractsMapEntryList{}(SortK{}) : SortOtherContractsMapEntryList{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:OtherContractsMapEntryList%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'OutputGroup{}(SortK{}) : SortOutputGroup{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:OutputGroup%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'OutputStack{}(SortK{}) : SortOutputStack{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:OutputStack%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Pair{}(SortK{}) : SortPair{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Pair%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'ParameterDecl{}(SortK{}) : SortParameterDecl{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:ParameterDecl%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'ParameterGroup{}(SortK{}) : SortParameterGroup{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:ParameterGroup%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'ParameterValueGroup{}(SortK{}) : SortParameterValueGroup{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:ParameterValueGroup%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'ParamtypeCell{}(SortK{}) : SortParamtypeCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:ParamtypeCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'ParamtypeCellOpt{}(SortK{}) : SortParamtypeCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:ParamtypeCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'ParamvalueCell{}(SortK{}) : SortParamvalueCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:ParamvalueCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'ParamvalueCellOpt{}(SortK{}) : SortParamvalueCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:ParamvalueCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Pgm{}(SortK{}) : SortPgm{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Pgm%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'PostCell{}(SortK{}) : SortPostCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:PostCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'PostCellOpt{}(SortK{}) : SortPostCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:PostCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'PostconditionGroup{}(SortK{}) : SortPostconditionGroup{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:PostconditionGroup%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'PreCell{}(SortK{}) : SortPreCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:PreCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'PreCellOpt{}(SortK{}) : SortPreCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:PreCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'PreData{}(SortK{}) : SortPreData{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:PreData%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'PreType{}(SortK{}) : SortPreType{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:PreType%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'PreconditionGroup{}(SortK{}) : SortPreconditionGroup{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:PreconditionGroup%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'ReturncodeCell{}(SortK{}) : SortReturncodeCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:ReturncodeCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'ReturncodeCellOpt{}(SortK{}) : SortReturncodeCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:ReturncodeCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'ScriptCell{}(SortK{}) : SortScriptCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:ScriptCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'ScriptCellOpt{}(SortK{}) : SortScriptCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:ScriptCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'SelfGroup{}(SortK{}) : SortSelfGroup{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:SelfGroup%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'SenderGroup{}(SortK{}) : SortSenderGroup{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:SenderGroup%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'SenderaddrCell{}(SortK{}) : SortSenderaddrCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:SenderaddrCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'SenderaddrCellOpt{}(SortK{}) : SortSenderaddrCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:SenderaddrCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'SequenceData{}(SortK{}) : SortSequenceData{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:SequenceData%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Set{}(SortK{}) : SortSet{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Set%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Signature{}(SortK{}) : SortSignature{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Signature%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Signedness{}(SortK{}) : SortSignedness{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Signedness%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'SimpleData{}(SortK{}) : SortSimpleData{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:SimpleData%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'SimpleType{}(SortK{}) : SortSimpleType{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:SimpleType%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'SourceGroup{}(SortK{}) : SortSourceGroup{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:SourceGroup%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'SourceaddrCell{}(SortK{}) : SortSourceaddrCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:SourceaddrCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'SourceaddrCellOpt{}(SortK{}) : SortSourceaddrCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:SourceaddrCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Stack{}(SortK{}) : SortStack{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Stack%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'StackCell{}(SortK{}) : SortStackCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:StackCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'StackCellOpt{}(SortK{}) : SortStackCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:StackCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'StackElement{}(SortK{}) : SortStackElement{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:StackElement%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'StackElementList{}(SortK{}) : SortStackElementList{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:StackElementList%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'StackElementLiteral{}(SortK{}) : SortStackElementLiteral{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:StackElementLiteral%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'StorageDecl{}(SortK{}) : SortStorageDecl{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:StorageDecl%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'StorageValueGroup{}(SortK{}) : SortStorageValueGroup{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:StorageValueGroup%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'StoragetypeCell{}(SortK{}) : SortStoragetypeCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:StoragetypeCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'StoragetypeCellOpt{}(SortK{}) : SortStoragetypeCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:StoragetypeCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'StoragevalueCell{}(SortK{}) : SortStoragevalueCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:StoragevalueCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'StoragevalueCellOpt{}(SortK{}) : SortStoragevalueCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:StoragevalueCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Stream{}(SortK{}) : SortStream{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Stream%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'String{}(SortK{}) : SortString{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:String%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'SymbolicData{}(SortK{}) : SortSymbolicData{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:SymbolicData%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'SymbolicElement{}(SortK{}) : SortSymbolicElement{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:SymbolicElement%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'SymbolsCell{}(SortK{}) : SortSymbolsCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:SymbolsCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'SymbolsCellOpt{}(SortK{}) : SortSymbolsCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:SymbolsCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Timestamp{}(SortK{}) : SortTimestamp{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Timestamp%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'TraceCell{}(SortK{}) : SortTraceCell{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:TraceCell%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'TraceCellOpt{}(SortK{}) : SortTraceCellOpt{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:TraceCellOpt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'Type{}(SortK{}) : SortType{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:Type%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'TypeAnnotation{}(SortK{}) : SortTypeAnnotation{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:TypeAnnotation%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'TypeName{}(SortK{}) : SortTypeName{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:TypeName%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'TypedData{}(SortK{}) : SortTypedData{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:TypedData%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'TypedSymbol{}(SortK{}) : SortTypedSymbol{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:TypedSymbol%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'UnaryTypeName{}(SortK{}) : SortUnaryTypeName{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:UnaryTypeName%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'UnificationFailure{}(SortK{}) : SortUnificationFailure{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:UnificationFailure%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'UnifiedList{}(SortK{}) : SortUnifiedList{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:UnifiedList%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'UnifiedSet{}(SortK{}) : SortUnifiedSet{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:UnifiedSet%r %c(%r %1 %c)%r"), function{}()] + symbol Lblproject'Coln'VariableAnnotation{}(SortK{}) : SortVariableAnnotation{} [priorities{}(), right{}(), terminals{}("1101"), projection{}(), left{}(), format{}("%cproject:VariableAnnotation%r %c(%r %1 %c)%r"), function{}()] + hooked-symbol LblrandInt'LParUndsRParUnds'INT'Unds'Int'Unds'Int{}(SortInt{}) : SortInt{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("randInt"), hook{}("INT.rand"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1082,18,1082,56)"), left{}(), format{}("%crandInt%r %c(%r %1 %c)%r"), function{}()] + hooked-symbol LblremoveAll'LParUndsCommUndsRParUnds'MAP'Unds'Map'Unds'Map'Unds'Set{}(SortMap{}, SortSet{}) : SortMap{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("removeAll"), hook{}("MAP.removeAll"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(334,18,334,91)"), left{}(), format{}("%cremoveAll%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + hooked-symbol Lblreplace'LParUndsCommUndsCommUndsCommUndsRParUnds'STRING-COMMON'Unds'String'Unds'String'Unds'String'Unds'String'Unds'Int{}(SortString{}, SortString{}, SortString{}, SortInt{}) : SortString{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101010101"), hook{}("STRING.replace"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1455,21,1455,145)"), left{}(), format{}("%creplace%r %c(%r %1 %c,%r %2 %c,%r %3 %c,%r %4 %c)%r"), function{}()] + hooked-symbol LblreplaceAll'LParUndsCommUndsCommUndsRParUnds'STRING-COMMON'Unds'String'Unds'String'Unds'String'Unds'String{}(SortString{}, SortString{}, SortString{}) : SortString{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("11010101"), hook{}("STRING.replaceAll"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1454,21,1454,153)"), left{}(), format{}("%creplaceAll%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), function{}()] + hooked-symbol LblreplaceAtBytes'LParUndsCommUndsCommUndsRParUnds'BYTES-HOOKED'Unds'Bytes'Unds'Bytes'Unds'Int'Unds'Bytes{}(SortBytes{}, SortInt{}, SortBytes{}) : SortBytes{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("11010101"), klabel{}("replaceAtBytes"), hook{}("BYTES.replaceAt"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1721,20,1721,104)"), left{}(), format{}("%creplaceAtBytes%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), function{}()] + hooked-symbol LblreplaceFirst'LParUndsCommUndsCommUndsRParUnds'STRING-COMMON'Unds'String'Unds'String'Unds'String'Unds'String{}(SortString{}, SortString{}, SortString{}) : SortString{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("11010101"), hook{}("STRING.replaceFirst"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1456,21,1456,155)"), left{}(), format{}("%creplaceFirst%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), function{}()] + hooked-symbol LblreverseBytes'LParUndsRParUnds'BYTES-HOOKED'Unds'Bytes'Unds'Bytes{}(SortBytes{}) : SortBytes{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("reverseBytes"), hook{}("BYTES.reverse"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1744,20,1744,82)"), left{}(), format{}("%creverseBytes%r %c(%r %1 %c)%r"), function{}()] + symbol LblreverseStack'LParUndsRParUnds'MICHELSON-COMMON'Unds'Stack'Unds'Stack{}(SortStack{}) : SortStack{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("reverseStack"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(48,20,48,58)"), left{}(), format{}("%creverseStack%r %c(%r %1 %c)%r"), function{}()] + symbol LblreverseStack'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Stack'Unds'Stack'Unds'Stack{}(SortStack{}, SortStack{}) : SortStack{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("reverseStack"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(49,20,49,58)"), left{}(), format{}("%creverseStack%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + hooked-symbol LblrfindChar'LParUndsCommUndsCommUndsRParUnds'STRING-COMMON'Unds'Int'Unds'String'Unds'String'Unds'Int{}(SortString{}, SortString{}, SortInt{}) : SortInt{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("11010101"), klabel{}("rfindChar"), hook{}("STRING.rfindChar"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1396,18,1396,116)"), left{}(), format{}("%crfindChar%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), function{}()] + hooked-symbol LblrfindString'LParUndsCommUndsCommUndsRParUnds'STRING-COMMON'Unds'Int'Unds'String'Unds'String'Unds'Int{}(SortString{}, SortString{}, SortInt{}) : SortInt{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("11010101"), klabel{}("rfindString"), hook{}("STRING.rfind"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1385,18,1385,111)"), left{}(), format{}("%crfindString%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), function{}()] + symbol Lblself'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'SelfGroup'Unds'String{}(SortString{}) : SortSelfGroup{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(359,24,359,36)"), left{}(), format{}("%cself%r %1"), injective{}()] + symbol Lblsender'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'SenderGroup'Unds'String{}(SortString{}) : SortSenderGroup{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(356,26,356,40)"), left{}(), format{}("%csender%r %1"), injective{}()] + symbol Lblset'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}() : SortUnaryTypeName{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(177,30,177,34)"), left{}(), format{}("%cset%r"), injective{}()] + hooked-symbol LblsignExtendBitRangeInt'LParUndsCommUndsCommUndsRParUnds'INT-COMMON'Unds'Int'Unds'Int'Unds'Int'Unds'Int{}(SortInt{}, SortInt{}, SortInt{}) : SortInt{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("11010101"), klabel{}("signExtendBitRangeInt"), hook{}("INT.signExtendBitRange"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(954,18,954,112)"), left{}(), format{}("%csignExtendBitRangeInt%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), function{}()] + symbol Lblsignature'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}() : SortNullaryTypeName{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(171,30,171,40)"), left{}(), format{}("%csignature%r"), injective{}()] + symbol LblsignedBytes{}() : SortSignedness{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("signedBytes"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1635,25,1635,62)"), left{}(), format{}("%cSigned%r"), injective{}()] + hooked-symbol Lblsize'LParUndsRParUnds'LIST'Unds'Int'Unds'List{}(SortList{}) : SortInt{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), smtlib{}("smt_seq_len"), terminals{}("1101"), klabel{}("sizeList"), hook{}("LIST.size"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(702,18,702,121)"), left{}(), format{}("%csize%r %c(%r %1 %c)%r"), function{}()] + hooked-symbol Lblsize'LParUndsRParUnds'MAP'Unds'Int'Unds'Map{}(SortMap{}) : SortInt{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("sizeMap"), hook{}("MAP.size"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(374,18,374,103)"), left{}(), format{}("%csize%r %c(%r %1 %c)%r"), function{}()] + hooked-symbol Lblsize'LParUndsRParUnds'SET'Unds'Int'Unds'Set{}(SortSet{}) : SortInt{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("size"), hook{}("SET.size"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(564,18,564,80)"), left{}(), format{}("%csize%r %c(%r %1 %c)%r"), function{}()] + symbol Lblsource'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'SourceGroup'Unds'String{}(SortString{}) : SortSourceGroup{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(357,26,357,40)"), left{}(), format{}("%csource%r %1"), injective{}()] + hooked-symbol LblsrandInt'LParUndsRParUnds'INT'Unds'K'Unds'Int{}(SortInt{}) : SortK{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("srandInt"), hook{}("INT.srand"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1083,16,1083,56)"), left{}(), format{}("%csrandInt%r %c(%r %1 %c)%r"), function{}()] + symbol Lblstorage'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'StorageDecl'Unds'Type{}(SortType{}) : SortStorageDecl{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(300,26,300,39)"), left{}(), format{}("%cstorage%r %1"), injective{}()] + symbol Lblstorage'Unds'value'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'StorageValueGroup'Unds'Data{}(SortData{}) : SortStorageValueGroup{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("10"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(364,32,364,51)"), left{}(), format{}("%cstorage_value%r %1"), injective{}()] + symbol Lblstring'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}() : SortNullaryTypeName{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(162,30,162,37)"), left{}(), format{}("%cstring%r"), injective{}()] + hooked-symbol LblsubstrBytes'LParUndsCommUndsCommUndsRParUnds'BYTES-HOOKED'Unds'Bytes'Unds'Bytes'Unds'Int'Unds'Int{}(SortBytes{}, SortInt{}, SortInt{}) : SortBytes{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("11010101"), klabel{}("substrBytes"), hook{}("BYTES.substr"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1709,20,1709,100)"), left{}(), format{}("%csubstrBytes%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), function{}()] + hooked-symbol LblsubstrString'LParUndsCommUndsCommUndsRParUnds'STRING-COMMON'Unds'String'Unds'String'Unds'Int'Unds'Int{}(SortString{}, SortInt{}, SortInt{}) : SortString{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("11010101"), klabel{}("substrString"), hook{}("STRING.substr"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1375,21,1375,121)"), left{}(), format{}("%csubstrString%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), function{}()] + symbol Lbltimestamp'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}() : SortNullaryTypeName{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(167,30,167,40)"), left{}(), format{}("%ctimestamp%r"), injective{}()] + symbol Lblunit'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}() : SortNullaryTypeName{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("1"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(170,30,170,35)"), left{}(), format{}("%cunit%r"), injective{}()] + symbol LblunsignedBytes{}() : SortSignedness{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(), right{}(), terminals{}("1"), klabel{}("unsignedBytes"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1636,25,1636,66)"), left{}(), format{}("%cUnsigned%r"), injective{}()] + hooked-symbol LblupdateList'LParUndsCommUndsCommUndsRParUnds'LIST'Unds'List'Unds'List'Unds'Int'Unds'List{}(SortList{}, SortInt{}, SortList{}) : SortList{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("11010101"), klabel{}("updateList"), hook{}("LIST.updateAll"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(666,19,666,96)"), left{}(), format{}("%cupdateList%r %c(%r %1 %c,%r %2 %c,%r %3 %c)%r"), function{}()] + hooked-symbol LblupdateMap'LParUndsCommUndsRParUnds'MAP'Unds'Map'Unds'Map'Unds'Map{}(SortMap{}, SortMap{}) : SortMap{} [functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("110101"), klabel{}("updateMap"), hook{}("MAP.updateAll"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(325,18,325,91)"), left{}(), format{}("%cupdateMap%r %c(%r %1 %c,%r %2 %c)%r"), function{}()] + hooked-symbol Lblvalues'LParUndsRParUnds'MAP'Unds'List'Unds'Map{}(SortMap{}) : SortList{} [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), priorities{}(), right{}(), terminals{}("1101"), klabel{}("values"), hook{}("MAP.values"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(366,19,366,76)"), left{}(), format{}("%cvalues%r %c(%r %1 %c)%r"), function{}()] + symbol Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Block'Unds'DataList{}(SortDataList{}) : SortBlock{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(113,20,113,35)"), left{}(), format{}("%c{%r %1 %c}%r"), injective{}()] + symbol Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'MapLiteral'Unds'MapEntryList{}(SortMapEntryList{}) : SortMapLiteral{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(109,25,109,44)"), left{}(), format{}("%c{%r %1 %c}%r"), injective{}()] + symbol Lbl'LBraUndsRBraUnds'UNIT-TEST-COMMON-SYNTAX'Unds'LiteralStack'Unds'StackElementList{}(SortStackElementList{}) : SortLiteralStack{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("101"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(652,27,652,50)"), left{}(), format{}("%c{%r %1 %c}%r"), injective{}()] + symbol Lbl'LBraRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'EmptyBlock{}() : SortEmptyBlock{} [functional{}(), constructor{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/syntax.md)"), priorities{}(), right{}(), terminals{}("11"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(111,25,111,31)"), left{}(), format{}("%c{%r %c}%r"), injective{}()] + hooked-symbol Lbl'Tild'Int'Unds'{}(SortInt{}) : SortInt{} [latex{}("\\mathop{\\sim_{\\scriptstyle\\it Int}}{#1}"), functional{}(), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), symbol'Kywd'{}(), priorities{}(Lbl'UndsPlus'Int'Unds'{}(),Lbl'Unds'divInt'Unds'{}(),Lbl'UndsPerc'Int'Unds'{}(),Lbl'Unds-GT--GT-'Int'Unds'{}(),Lbl'Unds'xorInt'Unds'{}(),Lbl'UndsSlsh'Int'Unds'{}(),Lbl'UndsAnd-'Int'Unds'{}(),Lbl'UndsXor-'Int'Unds'{}(),Lbl'Unds-LT--LT-'Int'Unds'{}(),Lbl'UndsStar'Int'Unds'{}(),Lbl'UndsPipe'Int'Unds'{}(),Lbl'Unds'modInt'Unds'{}(),Lbl'UndsXor-Perc'Int'UndsUnds'{}(),Lbl'Unds'-Int'Unds'{}()), right{}(), smtlib{}("notInt"), terminals{}("10"), klabel{}("~Int_"), hook{}("INT.not"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(887,18,887,172)"), left{}(), format{}("%c~Int%r %1"), function{}()] + +// generated axioms + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortUnifiedSet{}, SortKItem{}} (From:SortUnifiedSet{}))) [subsort{SortUnifiedSet{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortCell{}, SortKItem{}} (From:SortCell{}))) [subsort{SortCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortSymbolicData{}, SortKItem{}} (From:SortSymbolicData{}))) [subsort{SortSymbolicData{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortIOString{}, SortKItem{}} (From:SortIOString{}))) [subsort{SortIOString{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortString{}, SortKItem{}} (From:SortString{}))) [subsort{SortString{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortCutpointsCell{}, SortCell{}} (From:SortCutpointsCell{}))) [subsort{SortCutpointsCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortGroup{}, \equals{SortGroup{}, R} (Val:SortGroup{}, inj{SortInvariantsGroup{}, SortGroup{}} (From:SortInvariantsGroup{}))) [subsort{SortInvariantsGroup{}, SortGroup{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortError{}, SortKItem{}} (From:SortError{}))) [subsort{SortError{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortGroup{}, SortKItem{}} (From:SortGroup{}))) [subsort{SortGroup{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortSimpleData{}, \equals{SortSimpleData{}, R} (Val:SortSimpleData{}, inj{SortContractData{}, SortSimpleData{}} (From:SortContractData{}))) [subsort{SortContractData{}, SortSimpleData{}}()] // subsort + axiom{R} \exists{R} (Val:SortSimpleData{}, \equals{SortSimpleData{}, R} (Val:SortSimpleData{}, inj{SortAddress{}, SortSimpleData{}} (From:SortAddress{}))) [subsort{SortAddress{}, SortSimpleData{}}()] // subsort + axiom{R} \exists{R} (Val:SortGroups{}, \equals{SortGroups{}, R} (Val:SortGroups{}, inj{SortGroup{}, SortGroups{}} (From:SortGroup{}))) [subsort{SortGroup{}, SortGroups{}}()] // subsort + axiom{R} \exists{R} (Val:SortUnifiedSet{}, \equals{SortUnifiedSet{}, R} (Val:SortUnifiedSet{}, inj{SortSet{}, SortUnifiedSet{}} (From:SortSet{}))) [subsort{SortSet{}, SortUnifiedSet{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortSourceGroup{}, SortKItem{}} (From:SortSourceGroup{}))) [subsort{SortSourceGroup{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortMichelsonTopCellFragment{}, SortKItem{}} (From:SortMichelsonTopCellFragment{}))) [subsort{SortMichelsonTopCellFragment{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortBlockList{}, SortKItem{}} (From:SortBlockList{}))) [subsort{SortBlockList{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortStackElementList{}, SortKItem{}} (From:SortStackElementList{}))) [subsort{SortStackElementList{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortMyamountCellOpt{}, SortKItem{}} (From:SortMyamountCellOpt{}))) [subsort{SortMyamountCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortParameterValueGroup{}, SortKItem{}} (From:SortParameterValueGroup{}))) [subsort{SortParameterValueGroup{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortSimpleType{}, SortKItem{}} (From:SortSimpleType{}))) [subsort{SortSimpleType{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortStoragetypeCellOpt{}, \equals{SortStoragetypeCellOpt{}, R} (Val:SortStoragetypeCellOpt{}, inj{SortStoragetypeCell{}, SortStoragetypeCellOpt{}} (From:SortStoragetypeCell{}))) [subsort{SortStoragetypeCell{}, SortStoragetypeCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortParamvalueCellOpt{}, SortKItem{}} (From:SortParamvalueCellOpt{}))) [subsort{SortParamvalueCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortMBytesLiteral{}, SortKItem{}} (From:SortMBytesLiteral{}))) [subsort{SortMBytesLiteral{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortTypeName{}, SortKItem{}} (From:SortTypeName{}))) [subsort{SortTypeName{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortDataOrSeq{}, \equals{SortDataOrSeq{}, R} (Val:SortDataOrSeq{}, inj{SortData{}, SortDataOrSeq{}} (From:SortData{}))) [subsort{SortData{}, SortDataOrSeq{}}()] // subsort + axiom{R} \exists{R} (Val:SortMyamountCellOpt{}, \equals{SortMyamountCellOpt{}, R} (Val:SortMyamountCellOpt{}, inj{SortMyamountCell{}, SortMyamountCellOpt{}} (From:SortMyamountCell{}))) [subsort{SortMyamountCell{}, SortMyamountCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortStoragetypeCell{}, SortCell{}} (From:SortStoragetypeCell{}))) [subsort{SortStoragetypeCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortNullaryTypeName{}, SortKItem{}} (From:SortNullaryTypeName{}))) [subsort{SortNullaryTypeName{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortGroup{}, \equals{SortGroup{}, R} (Val:SortGroup{}, inj{SortBigMapGroup{}, SortGroup{}} (From:SortBigMapGroup{}))) [subsort{SortBigMapGroup{}, SortGroup{}}()] // subsort + axiom{R} \exists{R} (Val:SortGroup{}, \equals{SortGroup{}, R} (Val:SortGroup{}, inj{SortOutputGroup{}, SortGroup{}} (From:SortOutputGroup{}))) [subsort{SortOutputGroup{}, SortGroup{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortFailedStack{}, SortKItem{}} (From:SortFailedStack{}))) [subsort{SortFailedStack{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortBytes{}, SortKItem{}} (From:SortBytes{}))) [subsort{SortBytes{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortReturncodeCellOpt{}, \equals{SortReturncodeCellOpt{}, R} (Val:SortReturncodeCellOpt{}, inj{SortReturncodeCell{}, SortReturncodeCellOpt{}} (From:SortReturncodeCell{}))) [subsort{SortReturncodeCell{}, SortReturncodeCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortType{}, SortKItem{}} (From:SortType{}))) [subsort{SortType{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortMyamountCell{}, SortCell{}} (From:SortMyamountCell{}))) [subsort{SortMyamountCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortKnownaddrsCellOpt{}, \equals{SortKnownaddrsCellOpt{}, R} (Val:SortKnownaddrsCellOpt{}, inj{SortKnownaddrsCell{}, SortKnownaddrsCellOpt{}} (From:SortKnownaddrsCell{}))) [subsort{SortKnownaddrsCell{}, SortKnownaddrsCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortAssumeFailedCell{}, SortCell{}} (From:SortAssumeFailedCell{}))) [subsort{SortAssumeFailedCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortVariableAnnotation{}, SortKItem{}} (From:SortVariableAnnotation{}))) [subsort{SortVariableAnnotation{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortKCellOpt{}, SortKItem{}} (From:SortKCellOpt{}))) [subsort{SortKCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortInternalStack{}, \equals{SortInternalStack{}, R} (Val:SortInternalStack{}, inj{SortStack{}, SortInternalStack{}} (From:SortStack{}))) [subsort{SortStack{}, SortInternalStack{}}()] // subsort + axiom{R} \exists{R} (Val:SortGroup{}, \equals{SortGroup{}, R} (Val:SortGroup{}, inj{SortParameterDecl{}, SortGroup{}} (From:SortParameterDecl{}))) [subsort{SortParameterDecl{}, SortGroup{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortBigmapsCell{}, SortCell{}} (From:SortBigmapsCell{}))) [subsort{SortBigmapsCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortData{}, \equals{SortData{}, R} (Val:SortData{}, inj{SortMap{}, SortData{}} (From:SortMap{}))) [subsort{SortMap{}, SortData{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortNonceCell{}, SortCell{}} (From:SortNonceCell{}))) [subsort{SortNonceCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortGeneratedCounterCellOpt{}, SortKItem{}} (From:SortGeneratedCounterCellOpt{}))) [subsort{SortGeneratedCounterCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortLambdaData{}, SortKItem{}} (From:SortLambdaData{}))) [subsort{SortLambdaData{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortKResult{}, SortKItem{}} (From:SortKResult{}))) [subsort{SortKResult{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortSequenceData{}, \equals{SortSequenceData{}, R} (Val:SortSequenceData{}, inj{SortMapLiteral{}, SortSequenceData{}} (From:SortMapLiteral{}))) [subsort{SortMapLiteral{}, SortSequenceData{}}()] // subsort + axiom{R} \exists{R} (Val:SortKResult{}, \equals{SortKResult{}, R} (Val:SortKResult{}, inj{SortSimpleData{}, SortKResult{}} (From:SortSimpleData{}))) [subsort{SortSimpleData{}, SortKResult{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortPostCell{}, SortKItem{}} (From:SortPostCell{}))) [subsort{SortPostCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortOutputGroup{}, SortKItem{}} (From:SortOutputGroup{}))) [subsort{SortOutputGroup{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortGeneratedCounterCellOpt{}, \equals{SortGeneratedCounterCellOpt{}, R} (Val:SortGeneratedCounterCellOpt{}, inj{SortGeneratedCounterCell{}, SortGeneratedCounterCellOpt{}} (From:SortGeneratedCounterCell{}))) [subsort{SortGeneratedCounterCell{}, SortGeneratedCounterCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortTraceCell{}, SortKItem{}} (From:SortTraceCell{}))) [subsort{SortTraceCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortSimpleData{}, \equals{SortSimpleData{}, R} (Val:SortSimpleData{}, inj{SortString{}, SortSimpleData{}} (From:SortString{}))) [subsort{SortString{}, SortSimpleData{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortOrData{}, SortKItem{}} (From:SortOrData{}))) [subsort{SortOrData{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortAnnotation{}, \equals{SortAnnotation{}, R} (Val:SortAnnotation{}, inj{SortVariableAnnotation{}, SortAnnotation{}} (From:SortVariableAnnotation{}))) [subsort{SortVariableAnnotation{}, SortAnnotation{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortKCell{}, SortKItem{}} (From:SortKCell{}))) [subsort{SortKCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortMynowCellOpt{}, \equals{SortMynowCellOpt{}, R} (Val:SortMynowCellOpt{}, inj{SortMynowCell{}, SortMynowCellOpt{}} (From:SortMynowCell{}))) [subsort{SortMynowCell{}, SortMynowCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortNullaryTypeName{}, \equals{SortNullaryTypeName{}, R} (Val:SortNullaryTypeName{}, inj{SortNumTypeName{}, SortNullaryTypeName{}} (From:SortNumTypeName{}))) [subsort{SortNumTypeName{}, SortNullaryTypeName{}}()] // subsort + axiom{R} \exists{R} (Val:SortMyaddrCellOpt{}, \equals{SortMyaddrCellOpt{}, R} (Val:SortMyaddrCellOpt{}, inj{SortMyaddrCell{}, SortMyaddrCellOpt{}} (From:SortMyaddrCell{}))) [subsort{SortMyaddrCell{}, SortMyaddrCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortStoragevalueCellOpt{}, \equals{SortStoragevalueCellOpt{}, R} (Val:SortStoragevalueCellOpt{}, inj{SortStoragevalueCell{}, SortStoragevalueCellOpt{}} (From:SortStoragevalueCell{}))) [subsort{SortStoragevalueCell{}, SortStoragevalueCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortGroup{}, \equals{SortGroup{}, R} (Val:SortGroup{}, inj{SortCodeGroup{}, SortGroup{}} (From:SortCodeGroup{}))) [subsort{SortCodeGroup{}, SortGroup{}}()] // subsort + axiom{R} \exists{R} (Val:SortData{}, \equals{SortData{}, R} (Val:SortData{}, inj{SortOptionData{}, SortData{}} (From:SortOptionData{}))) [subsort{SortOptionData{}, SortData{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortSourceaddrCell{}, SortKItem{}} (From:SortSourceaddrCell{}))) [subsort{SortSourceaddrCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortContract{}, SortKItem{}} (From:SortContract{}))) [subsort{SortContract{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortBlock{}, \equals{SortBlock{}, R} (Val:SortBlock{}, inj{SortEmptyBlock{}, SortBlock{}} (From:SortEmptyBlock{}))) [subsort{SortEmptyBlock{}, SortBlock{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortTypeAnnotation{}, SortKItem{}} (From:SortTypeAnnotation{}))) [subsort{SortTypeAnnotation{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortGroup{}, \equals{SortGroup{}, R} (Val:SortGroup{}, inj{SortNowGroup{}, SortGroup{}} (From:SortNowGroup{}))) [subsort{SortNowGroup{}, SortGroup{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortSourceaddrCellOpt{}, SortKItem{}} (From:SortSourceaddrCellOpt{}))) [subsort{SortSourceaddrCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortDataList{}, \equals{SortDataList{}, R} (Val:SortDataList{}, inj{SortData{}, SortDataList{}} (From:SortData{}))) [subsort{SortData{}, SortDataList{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortMapTypeName{}, SortKItem{}} (From:SortMapTypeName{}))) [subsort{SortMapTypeName{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortInstruction{}, SortKItem{}} (From:SortInstruction{}))) [subsort{SortInstruction{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortData{}, \equals{SortData{}, R} (Val:SortData{}, inj{SortPair{}, SortData{}} (From:SortPair{}))) [subsort{SortPair{}, SortData{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortExpectedCell{}, SortKItem{}} (From:SortExpectedCell{}))) [subsort{SortExpectedCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortMichelsonTopCell{}, SortCell{}} (From:SortMichelsonTopCell{}))) [subsort{SortMichelsonTopCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortCutpointsCellOpt{}, SortKItem{}} (From:SortCutpointsCellOpt{}))) [subsort{SortCutpointsCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortMaybeTypeName{}, \equals{SortMaybeTypeName{}, R} (Val:SortMaybeTypeName{}, inj{SortTypeName{}, SortMaybeTypeName{}} (From:SortTypeName{}))) [subsort{SortTypeName{}, SortMaybeTypeName{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortSenderaddrCell{}, SortKItem{}} (From:SortSenderaddrCell{}))) [subsort{SortSenderaddrCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortKnownaddrsCell{}, SortCell{}} (From:SortKnownaddrsCell{}))) [subsort{SortKnownaddrsCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortBigmapsCell{}, SortKItem{}} (From:SortBigmapsCell{}))) [subsort{SortBigmapsCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortIOInt{}, \equals{SortIOInt{}, R} (Val:SortIOInt{}, inj{SortIOError{}, SortIOInt{}} (From:SortIOError{}))) [subsort{SortIOError{}, SortIOInt{}}()] // subsort + axiom{R} \exists{R} (Val:SortKCellOpt{}, \equals{SortKCellOpt{}, R} (Val:SortKCellOpt{}, inj{SortKCell{}, SortKCellOpt{}} (From:SortKCell{}))) [subsort{SortKCell{}, SortKCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortPreCell{}, SortCell{}} (From:SortPreCell{}))) [subsort{SortPreCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortBinaryTypeName{}, \equals{SortBinaryTypeName{}, R} (Val:SortBinaryTypeName{}, inj{SortMapTypeName{}, SortBinaryTypeName{}} (From:SortMapTypeName{}))) [subsort{SortMapTypeName{}, SortBinaryTypeName{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortMybalanceCellOpt{}, SortKItem{}} (From:SortMybalanceCellOpt{}))) [subsort{SortMybalanceCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortGroup{}, \equals{SortGroup{}, R} (Val:SortGroup{}, inj{SortChainGroup{}, SortGroup{}} (From:SortChainGroup{}))) [subsort{SortChainGroup{}, SortGroup{}}()] // subsort + axiom{R} \exists{R} (Val:SortInputstackCellOpt{}, \equals{SortInputstackCellOpt{}, R} (Val:SortInputstackCellOpt{}, inj{SortInputstackCell{}, SortInputstackCellOpt{}} (From:SortInputstackCell{}))) [subsort{SortInputstackCell{}, SortInputstackCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortBigmapsCellOpt{}, SortKItem{}} (From:SortBigmapsCellOpt{}))) [subsort{SortBigmapsCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortSimpleData{}, \equals{SortSimpleData{}, R} (Val:SortSimpleData{}, inj{SortSet{}, SortSimpleData{}} (From:SortSet{}))) [subsort{SortSet{}, SortSimpleData{}}()] // subsort + axiom{R} \exists{R} (Val:SortMutez{}, \equals{SortMutez{}, R} (Val:SortMutez{}, inj{SortInt{}, SortMutez{}} (From:SortInt{}))) [subsort{SortInt{}, SortMutez{}}()] // subsort + axiom{R} \exists{R} (Val:SortSimpleData{}, \equals{SortSimpleData{}, R} (Val:SortSimpleData{}, inj{SortMap{}, SortSimpleData{}} (From:SortMap{}))) [subsort{SortMap{}, SortSimpleData{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortSet{}, SortKItem{}} (From:SortSet{}))) [subsort{SortSet{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortDataList{}, SortKItem{}} (From:SortDataList{}))) [subsort{SortDataList{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortNonceCellOpt{}, SortKItem{}} (From:SortNonceCellOpt{}))) [subsort{SortNonceCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortStorageDecl{}, SortKItem{}} (From:SortStorageDecl{}))) [subsort{SortStorageDecl{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortCodeDecl{}, SortKItem{}} (From:SortCodeDecl{}))) [subsort{SortCodeDecl{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortIOError{}, SortKItem{}} (From:SortIOError{}))) [subsort{SortIOError{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortSimpleData{}, \equals{SortSimpleData{}, R} (Val:SortSimpleData{}, inj{SortChainId{}, SortSimpleData{}} (From:SortChainId{}))) [subsort{SortChainId{}, SortSimpleData{}}()] // subsort + axiom{R} \exists{R} (Val:SortDataOrSeq{}, \equals{SortDataOrSeq{}, R} (Val:SortDataOrSeq{}, inj{SortMapEntryList{}, SortDataOrSeq{}} (From:SortMapEntryList{}))) [subsort{SortMapEntryList{}, SortDataOrSeq{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortBlock{}, SortKItem{}} (From:SortBlock{}))) [subsort{SortBlock{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortSimpleData{}, \equals{SortSimpleData{}, R} (Val:SortSimpleData{}, inj{SortMutez{}, SortSimpleData{}} (From:SortMutez{}))) [subsort{SortMutez{}, SortSimpleData{}}()] // subsort + axiom{R} \exists{R} (Val:SortOutputStack{}, \equals{SortOutputStack{}, R} (Val:SortOutputStack{}, inj{SortFailedStack{}, SortOutputStack{}} (From:SortFailedStack{}))) [subsort{SortFailedStack{}, SortOutputStack{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortStoragevalueCellOpt{}, SortKItem{}} (From:SortStoragevalueCellOpt{}))) [subsort{SortStoragevalueCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortContractData{}, SortKItem{}} (From:SortContractData{}))) [subsort{SortContractData{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortGroup{}, \equals{SortGroup{}, R} (Val:SortGroup{}, inj{SortStorageDecl{}, SortGroup{}} (From:SortStorageDecl{}))) [subsort{SortStorageDecl{}, SortGroup{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortSignedness{}, SortKItem{}} (From:SortSignedness{}))) [subsort{SortSignedness{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortMychainidCellOpt{}, SortKItem{}} (From:SortMychainidCellOpt{}))) [subsort{SortMychainidCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortTypedData{}, SortKItem{}} (From:SortTypedData{}))) [subsort{SortTypedData{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortPreType{}, SortKItem{}} (From:SortPreType{}))) [subsort{SortPreType{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortParamvalueCellOpt{}, \equals{SortParamvalueCellOpt{}, R} (Val:SortParamvalueCellOpt{}, inj{SortParamvalueCell{}, SortParamvalueCellOpt{}} (From:SortParamvalueCell{}))) [subsort{SortParamvalueCell{}, SortParamvalueCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortGeneratedCounterCell{}, SortKItem{}} (From:SortGeneratedCounterCell{}))) [subsort{SortGeneratedCounterCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortBigmapsCellOpt{}, \equals{SortBigmapsCellOpt{}, R} (Val:SortBigmapsCellOpt{}, inj{SortBigmapsCell{}, SortBigmapsCellOpt{}} (From:SortBigmapsCell{}))) [subsort{SortBigmapsCell{}, SortBigmapsCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortPreCell{}, SortKItem{}} (From:SortPreCell{}))) [subsort{SortPreCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortParameterGroup{}, SortKItem{}} (From:SortParameterGroup{}))) [subsort{SortParameterGroup{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortLiteralStack{}, SortKItem{}} (From:SortLiteralStack{}))) [subsort{SortLiteralStack{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortIOInt{}, \equals{SortIOInt{}, R} (Val:SortIOInt{}, inj{SortInt{}, SortIOInt{}} (From:SortInt{}))) [subsort{SortInt{}, SortIOInt{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortEmptyBlock{}, SortKItem{}} (From:SortEmptyBlock{}))) [subsort{SortEmptyBlock{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortSimpleData{}, \equals{SortSimpleData{}, R} (Val:SortSimpleData{}, inj{SortKey{}, SortSimpleData{}} (From:SortKey{}))) [subsort{SortKey{}, SortSimpleData{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortInputstackCellOpt{}, SortKItem{}} (From:SortInputstackCellOpt{}))) [subsort{SortInputstackCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortPreData{}, \equals{SortPreData{}, R} (Val:SortPreData{}, inj{SortData{}, SortPreData{}} (From:SortData{}))) [subsort{SortData{}, SortPreData{}}()] // subsort + axiom{R} \exists{R} (Val:SortData{}, \equals{SortData{}, R} (Val:SortData{}, inj{SortInstruction{}, SortData{}} (From:SortInstruction{}))) [subsort{SortInstruction{}, SortData{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortExpectedCell{}, SortCell{}} (From:SortExpectedCell{}))) [subsort{SortExpectedCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortParameterGroup{}, \equals{SortParameterGroup{}, R} (Val:SortParameterGroup{}, inj{SortParameterDecl{}, SortParameterGroup{}} (From:SortParameterDecl{}))) [subsort{SortParameterDecl{}, SortParameterGroup{}}()] // subsort + axiom{R} \exists{R} (Val:SortTypeName{}, \equals{SortTypeName{}, R} (Val:SortTypeName{}, inj{SortNullaryTypeName{}, SortTypeName{}} (From:SortNullaryTypeName{}))) [subsort{SortNullaryTypeName{}, SortTypeName{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortInvariant{}, SortKItem{}} (From:SortInvariant{}))) [subsort{SortInvariant{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortParamvalueCell{}, SortKItem{}} (From:SortParamvalueCell{}))) [subsort{SortParamvalueCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortSourceaddrCellOpt{}, \equals{SortSourceaddrCellOpt{}, R} (Val:SortSourceaddrCellOpt{}, inj{SortSourceaddrCell{}, SortSourceaddrCellOpt{}} (From:SortSourceaddrCell{}))) [subsort{SortSourceaddrCell{}, SortSourceaddrCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortBigMapEntryList{}, SortKItem{}} (From:SortBigMapEntryList{}))) [subsort{SortBigMapEntryList{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortMyaddrCellOpt{}, SortKItem{}} (From:SortMyaddrCellOpt{}))) [subsort{SortMyaddrCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortScriptCellOpt{}, SortKItem{}} (From:SortScriptCellOpt{}))) [subsort{SortScriptCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortUnifiedSet{}, \equals{SortUnifiedSet{}, R} (Val:SortUnifiedSet{}, inj{SortUnificationFailure{}, SortUnifiedSet{}} (From:SortUnificationFailure{}))) [subsort{SortUnificationFailure{}, SortUnifiedSet{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortMapOpInfo{}, SortKItem{}} (From:SortMapOpInfo{}))) [subsort{SortMapOpInfo{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortAssumeFailedCell{}, SortKItem{}} (From:SortAssumeFailedCell{}))) [subsort{SortAssumeFailedCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortPreCellOpt{}, \equals{SortPreCellOpt{}, R} (Val:SortPreCellOpt{}, inj{SortPreCell{}, SortPreCellOpt{}} (From:SortPreCell{}))) [subsort{SortPreCell{}, SortPreCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortBoolExp{}, SortKItem{}} (From:SortBoolExp{}))) [subsort{SortBoolExp{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortMapEntry{}, SortKItem{}} (From:SortMapEntry{}))) [subsort{SortMapEntry{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortStack{}, SortKItem{}} (From:SortStack{}))) [subsort{SortStack{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortReturncodeCell{}, SortKItem{}} (From:SortReturncodeCell{}))) [subsort{SortReturncodeCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortStackElementLiteral{}, SortKItem{}} (From:SortStackElementLiteral{}))) [subsort{SortStackElementLiteral{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortSimpleData{}, \equals{SortSimpleData{}, R} (Val:SortSimpleData{}, inj{SortKeyHash{}, SortSimpleData{}} (From:SortKeyHash{}))) [subsort{SortKeyHash{}, SortSimpleData{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortSymbolicElement{}, SortKItem{}} (From:SortSymbolicElement{}))) [subsort{SortSymbolicElement{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortGroups{}, SortKItem{}} (From:SortGroups{}))) [subsort{SortGroups{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortContractGroup{}, SortKItem{}} (From:SortContractGroup{}))) [subsort{SortContractGroup{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortKey{}, SortKItem{}} (From:SortKey{}))) [subsort{SortKey{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortAnnotation{}, SortKItem{}} (From:SortAnnotation{}))) [subsort{SortAnnotation{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortPreCellOpt{}, SortKItem{}} (From:SortPreCellOpt{}))) [subsort{SortPreCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortOtherContractsMapEntry{}, SortKItem{}} (From:SortOtherContractsMapEntry{}))) [subsort{SortOtherContractsMapEntry{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortCutpointsCellOpt{}, \equals{SortCutpointsCellOpt{}, R} (Val:SortCutpointsCellOpt{}, inj{SortCutpointsCell{}, SortCutpointsCellOpt{}} (From:SortCutpointsCell{}))) [subsort{SortCutpointsCell{}, SortCutpointsCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortStream{}, SortKItem{}} (From:SortStream{}))) [subsort{SortStream{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortGroup{}, \equals{SortGroup{}, R} (Val:SortGroup{}, inj{SortSelfGroup{}, SortGroup{}} (From:SortSelfGroup{}))) [subsort{SortSelfGroup{}, SortGroup{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortIOFile{}, SortKItem{}} (From:SortIOFile{}))) [subsort{SortIOFile{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortUnifiedList{}, SortKItem{}} (From:SortUnifiedList{}))) [subsort{SortUnifiedList{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortInternalStack{}, SortKItem{}} (From:SortInternalStack{}))) [subsort{SortInternalStack{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortExpectedCellOpt{}, SortKItem{}} (From:SortExpectedCellOpt{}))) [subsort{SortExpectedCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortSimpleData{}, \equals{SortSimpleData{}, R} (Val:SortSimpleData{}, inj{SortBlockchainOperation{}, SortSimpleData{}} (From:SortBlockchainOperation{}))) [subsort{SortBlockchainOperation{}, SortSimpleData{}}()] // subsort + axiom{R} \exists{R} (Val:SortPreType{}, \equals{SortPreType{}, R} (Val:SortPreType{}, inj{SortType{}, SortPreType{}} (From:SortType{}))) [subsort{SortType{}, SortPreType{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortKnownaddrsCellOpt{}, SortKItem{}} (From:SortKnownaddrsCellOpt{}))) [subsort{SortKnownaddrsCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortUnificationFailure{}, SortKItem{}} (From:SortUnificationFailure{}))) [subsort{SortUnificationFailure{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortSimpleData{}, \equals{SortSimpleData{}, R} (Val:SortSimpleData{}, inj{SortSignature{}, SortSimpleData{}} (From:SortSignature{}))) [subsort{SortSignature{}, SortSimpleData{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortStackCell{}, SortKItem{}} (From:SortStackCell{}))) [subsort{SortStackCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortGroup{}, \equals{SortGroup{}, R} (Val:SortGroup{}, inj{SortPostconditionGroup{}, SortGroup{}} (From:SortPostconditionGroup{}))) [subsort{SortPostconditionGroup{}, SortGroup{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortGeneratedTopCell{}, SortKItem{}} (From:SortGeneratedTopCell{}))) [subsort{SortGeneratedTopCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortTypedSymbol{}, SortKItem{}} (From:SortTypedSymbol{}))) [subsort{SortTypedSymbol{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortInvsCell{}, SortKItem{}} (From:SortInvsCell{}))) [subsort{SortInvsCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortGroup{}, \equals{SortGroup{}, R} (Val:SortGroup{}, inj{SortSourceGroup{}, SortGroup{}} (From:SortSourceGroup{}))) [subsort{SortSourceGroup{}, SortGroup{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortPreData{}, SortKItem{}} (From:SortPreData{}))) [subsort{SortPreData{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortInternalStack{}, \equals{SortInternalStack{}, R} (Val:SortInternalStack{}, inj{SortFailedStack{}, SortInternalStack{}} (From:SortFailedStack{}))) [subsort{SortFailedStack{}, SortInternalStack{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortScriptCell{}, SortCell{}} (From:SortScriptCell{}))) [subsort{SortScriptCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortParamvalueCell{}, SortCell{}} (From:SortParamvalueCell{}))) [subsort{SortParamvalueCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortNonceCellOpt{}, \equals{SortNonceCellOpt{}, R} (Val:SortNonceCellOpt{}, inj{SortNonceCell{}, SortNonceCellOpt{}} (From:SortNonceCell{}))) [subsort{SortNonceCell{}, SortNonceCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortMyaddrCell{}, SortKItem{}} (From:SortMyaddrCell{}))) [subsort{SortMyaddrCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortDataOrSeq{}, SortKItem{}} (From:SortDataOrSeq{}))) [subsort{SortDataOrSeq{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortSenderGroup{}, SortKItem{}} (From:SortSenderGroup{}))) [subsort{SortSenderGroup{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortParamtypeCell{}, SortKItem{}} (From:SortParamtypeCell{}))) [subsort{SortParamtypeCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortTimestamp{}, SortKItem{}} (From:SortTimestamp{}))) [subsort{SortTimestamp{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortSymbolsCell{}, SortKItem{}} (From:SortSymbolsCell{}))) [subsort{SortSymbolsCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortMychainidCellOpt{}, \equals{SortMychainidCellOpt{}, R} (Val:SortMychainidCellOpt{}, inj{SortMychainidCell{}, SortMychainidCellOpt{}} (From:SortMychainidCell{}))) [subsort{SortMychainidCell{}, SortMychainidCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortSelfGroup{}, SortKItem{}} (From:SortSelfGroup{}))) [subsort{SortSelfGroup{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortGroup{}, \equals{SortGroup{}, R} (Val:SortGroup{}, inj{SortParameterGroup{}, SortGroup{}} (From:SortParameterGroup{}))) [subsort{SortParameterGroup{}, SortGroup{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortIOInt{}, SortKItem{}} (From:SortIOInt{}))) [subsort{SortIOInt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortMynowCellOpt{}, SortKItem{}} (From:SortMynowCellOpt{}))) [subsort{SortMynowCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortTraceCellOpt{}, SortKItem{}} (From:SortTraceCellOpt{}))) [subsort{SortTraceCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortBinaryTypeName{}, SortKItem{}} (From:SortBinaryTypeName{}))) [subsort{SortBinaryTypeName{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortSimpleData{}, \equals{SortSimpleData{}, R} (Val:SortSimpleData{}, inj{SortLambdaData{}, SortSimpleData{}} (From:SortLambdaData{}))) [subsort{SortLambdaData{}, SortSimpleData{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortChainId{}, SortKItem{}} (From:SortChainId{}))) [subsort{SortChainId{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortGroup{}, \equals{SortGroup{}, R} (Val:SortGroup{}, inj{SortInputGroup{}, SortGroup{}} (From:SortInputGroup{}))) [subsort{SortInputGroup{}, SortGroup{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortContractsGroup{}, SortKItem{}} (From:SortContractsGroup{}))) [subsort{SortContractsGroup{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortOtherContractsMapEntryList{}, SortKItem{}} (From:SortOtherContractsMapEntryList{}))) [subsort{SortOtherContractsMapEntryList{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortParamtypeCell{}, SortCell{}} (From:SortParamtypeCell{}))) [subsort{SortParamtypeCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortMBytes{}, \equals{SortMBytes{}, R} (Val:SortMBytes{}, inj{SortBytes{}, SortMBytes{}} (From:SortBytes{}))) [subsort{SortBytes{}, SortMBytes{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortSignature{}, SortKItem{}} (From:SortSignature{}))) [subsort{SortSignature{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortData{}, \equals{SortData{}, R} (Val:SortData{}, inj{SortOrData{}, SortData{}} (From:SortOrData{}))) [subsort{SortOrData{}, SortData{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortBigMapGroup{}, SortKItem{}} (From:SortBigMapGroup{}))) [subsort{SortBigMapGroup{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortInputGroup{}, SortKItem{}} (From:SortInputGroup{}))) [subsort{SortInputGroup{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortDataOrSeq{}, \equals{SortDataOrSeq{}, R} (Val:SortDataOrSeq{}, inj{SortDataList{}, SortDataOrSeq{}} (From:SortDataList{}))) [subsort{SortDataList{}, SortDataOrSeq{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortKnownaddrsCell{}, SortKItem{}} (From:SortKnownaddrsCell{}))) [subsort{SortKnownaddrsCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortSymbolsCellOpt{}, \equals{SortSymbolsCellOpt{}, R} (Val:SortSymbolsCellOpt{}, inj{SortSymbolsCell{}, SortSymbolsCellOpt{}} (From:SortSymbolsCell{}))) [subsort{SortSymbolsCell{}, SortSymbolsCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortInvsCell{}, SortCell{}} (From:SortInvsCell{}))) [subsort{SortInvsCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortMynowCell{}, SortKItem{}} (From:SortMynowCell{}))) [subsort{SortMynowCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortNowGroup{}, SortKItem{}} (From:SortNowGroup{}))) [subsort{SortNowGroup{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortReturncodeCellOpt{}, SortKItem{}} (From:SortReturncodeCellOpt{}))) [subsort{SortReturncodeCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortBlockchainOperation{}, SortKItem{}} (From:SortBlockchainOperation{}))) [subsort{SortBlockchainOperation{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortData{}, \equals{SortData{}, R} (Val:SortData{}, inj{SortSequenceData{}, SortData{}} (From:SortSequenceData{}))) [subsort{SortSequenceData{}, SortData{}}()] // subsort + axiom{R} \exists{R} (Val:SortData{}, \equals{SortData{}, R} (Val:SortData{}, inj{SortTypedData{}, SortData{}} (From:SortTypedData{}))) [subsort{SortTypedData{}, SortData{}}()] // subsort + axiom{R} \exists{R} (Val:SortData{}, \equals{SortData{}, R} (Val:SortData{}, inj{SortSet{}, SortData{}} (From:SortSet{}))) [subsort{SortSet{}, SortData{}}()] // subsort + axiom{R} \exists{R} (Val:SortGroup{}, \equals{SortGroup{}, R} (Val:SortGroup{}, inj{SortStorageValueGroup{}, SortGroup{}} (From:SortStorageValueGroup{}))) [subsort{SortStorageValueGroup{}, SortGroup{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortMychainidCell{}, SortCell{}} (From:SortMychainidCell{}))) [subsort{SortMychainidCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortParamtypeCellOpt{}, \equals{SortParamtypeCellOpt{}, R} (Val:SortParamtypeCellOpt{}, inj{SortParamtypeCell{}, SortParamtypeCellOpt{}} (From:SortParamtypeCell{}))) [subsort{SortParamtypeCell{}, SortParamtypeCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortList{}, SortKItem{}} (From:SortList{}))) [subsort{SortList{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortKeyHash{}, SortKItem{}} (From:SortKeyHash{}))) [subsort{SortKeyHash{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortMyaddrCell{}, SortCell{}} (From:SortMyaddrCell{}))) [subsort{SortMyaddrCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortStorageValueGroup{}, SortKItem{}} (From:SortStorageValueGroup{}))) [subsort{SortStorageValueGroup{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortMaybeTypeName{}, SortKItem{}} (From:SortMaybeTypeName{}))) [subsort{SortMaybeTypeName{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortAnnotationList{}, SortKItem{}} (From:SortAnnotationList{}))) [subsort{SortAnnotationList{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortPair{}, SortKItem{}} (From:SortPair{}))) [subsort{SortPair{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortChainGroup{}, SortKItem{}} (From:SortChainGroup{}))) [subsort{SortChainGroup{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortStoragetypeCellOpt{}, SortKItem{}} (From:SortStoragetypeCellOpt{}))) [subsort{SortStoragetypeCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortIOString{}, \equals{SortIOString{}, R} (Val:SortIOString{}, inj{SortString{}, SortIOString{}} (From:SortString{}))) [subsort{SortString{}, SortIOString{}}()] // subsort + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, inj{SortBlock{}, SortInstruction{}} (From:SortBlock{}))) [subsort{SortBlock{}, SortInstruction{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortBigMapEntry{}, SortKItem{}} (From:SortBigMapEntry{}))) [subsort{SortBigMapEntry{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortMybalanceCell{}, SortKItem{}} (From:SortMybalanceCell{}))) [subsort{SortMybalanceCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortMutez{}, SortKItem{}} (From:SortMutez{}))) [subsort{SortMutez{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortId{}, SortKItem{}} (From:SortId{}))) [subsort{SortId{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortGroup{}, \equals{SortGroup{}, R} (Val:SortGroup{}, inj{SortSenderGroup{}, SortGroup{}} (From:SortSenderGroup{}))) [subsort{SortSenderGroup{}, SortGroup{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortData{}, SortKItem{}} (From:SortData{}))) [subsort{SortData{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortBoolExp{}, \equals{SortBoolExp{}, R} (Val:SortBoolExp{}, inj{SortBool{}, SortBoolExp{}} (From:SortBool{}))) [subsort{SortBool{}, SortBoolExp{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortStackCellOpt{}, SortKItem{}} (From:SortStackCellOpt{}))) [subsort{SortStackCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortFloat{}, SortKItem{}} (From:SortFloat{}))) [subsort{SortFloat{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortGroup{}, \equals{SortGroup{}, R} (Val:SortGroup{}, inj{SortBalanceGroup{}, SortGroup{}} (From:SortBalanceGroup{}))) [subsort{SortBalanceGroup{}, SortGroup{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortSymbolsCellOpt{}, SortKItem{}} (From:SortSymbolsCellOpt{}))) [subsort{SortSymbolsCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortBool{}, SortKItem{}} (From:SortBool{}))) [subsort{SortBool{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortCodeGroup{}, SortKItem{}} (From:SortCodeGroup{}))) [subsort{SortCodeGroup{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortSimpleData{}, SortKItem{}} (From:SortSimpleData{}))) [subsort{SortSimpleData{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortOutputStack{}, \equals{SortOutputStack{}, R} (Val:SortOutputStack{}, inj{SortLiteralStack{}, SortOutputStack{}} (From:SortLiteralStack{}))) [subsort{SortLiteralStack{}, SortOutputStack{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortBalanceGroup{}, SortKItem{}} (From:SortBalanceGroup{}))) [subsort{SortBalanceGroup{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortMBytes{}, SortKItem{}} (From:SortMBytes{}))) [subsort{SortMBytes{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortScriptCell{}, SortKItem{}} (From:SortScriptCell{}))) [subsort{SortScriptCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortAddress{}, \equals{SortAddress{}, R} (Val:SortAddress{}, inj{SortString{}, SortAddress{}} (From:SortString{}))) [subsort{SortString{}, SortAddress{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortPostconditionGroup{}, SortKItem{}} (From:SortPostconditionGroup{}))) [subsort{SortPostconditionGroup{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortData{}, \equals{SortData{}, R} (Val:SortData{}, inj{SortFailedStack{}, SortData{}} (From:SortFailedStack{}))) [subsort{SortFailedStack{}, SortData{}}()] // subsort + axiom{R} \exists{R} (Val:SortMichelsonTopCellOpt{}, \equals{SortMichelsonTopCellOpt{}, R} (Val:SortMichelsonTopCellOpt{}, inj{SortMichelsonTopCell{}, SortMichelsonTopCellOpt{}} (From:SortMichelsonTopCell{}))) [subsort{SortMichelsonTopCell{}, SortMichelsonTopCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortSourceaddrCell{}, SortCell{}} (From:SortSourceaddrCell{}))) [subsort{SortSourceaddrCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortSimpleData{}, \equals{SortSimpleData{}, R} (Val:SortSimpleData{}, inj{SortTimestamp{}, SortSimpleData{}} (From:SortTimestamp{}))) [subsort{SortTimestamp{}, SortSimpleData{}}()] // subsort + axiom{R} \exists{R} (Val:SortGroup{}, \equals{SortGroup{}, R} (Val:SortGroup{}, inj{SortContractGroup{}, SortGroup{}} (From:SortContractGroup{}))) [subsort{SortContractGroup{}, SortGroup{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortAddress{}, SortKItem{}} (From:SortAddress{}))) [subsort{SortAddress{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortCutpointsCell{}, SortKItem{}} (From:SortCutpointsCell{}))) [subsort{SortCutpointsCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortFieldAnnotation{}, SortKItem{}} (From:SortFieldAnnotation{}))) [subsort{SortFieldAnnotation{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortAnnotation{}, \equals{SortAnnotation{}, R} (Val:SortAnnotation{}, inj{SortFieldAnnotation{}, SortAnnotation{}} (From:SortFieldAnnotation{}))) [subsort{SortFieldAnnotation{}, SortAnnotation{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortEndianness{}, SortKItem{}} (From:SortEndianness{}))) [subsort{SortEndianness{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortOperationNonce{}, SortKItem{}} (From:SortOperationNonce{}))) [subsort{SortOperationNonce{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortSenderaddrCellOpt{}, SortKItem{}} (From:SortSenderaddrCellOpt{}))) [subsort{SortSenderaddrCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortUnifiedList{}, \equals{SortUnifiedList{}, R} (Val:SortUnifiedList{}, inj{SortUnificationFailure{}, SortUnifiedList{}} (From:SortUnificationFailure{}))) [subsort{SortUnificationFailure{}, SortUnifiedList{}}()] // subsort + axiom{R} \exists{R} (Val:SortCodeGroup{}, \equals{SortCodeGroup{}, R} (Val:SortCodeGroup{}, inj{SortCodeDecl{}, SortCodeGroup{}} (From:SortCodeDecl{}))) [subsort{SortCodeDecl{}, SortCodeGroup{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortPostCellOpt{}, SortKItem{}} (From:SortPostCellOpt{}))) [subsort{SortPostCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortOptionData{}, SortKItem{}} (From:SortOptionData{}))) [subsort{SortOptionData{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortSimpleData{}, \equals{SortSimpleData{}, R} (Val:SortSimpleData{}, inj{SortMBytes{}, SortSimpleData{}} (From:SortMBytes{}))) [subsort{SortMBytes{}, SortSimpleData{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortStoragetypeCell{}, SortKItem{}} (From:SortStoragetypeCell{}))) [subsort{SortStoragetypeCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortAmountGroup{}, SortKItem{}} (From:SortAmountGroup{}))) [subsort{SortAmountGroup{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortAssumeFailedCellOpt{}, SortKItem{}} (From:SortAssumeFailedCellOpt{}))) [subsort{SortAssumeFailedCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortInputstackCell{}, SortKItem{}} (From:SortInputstackCell{}))) [subsort{SortInputstackCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortAnnotation{}, \equals{SortAnnotation{}, R} (Val:SortAnnotation{}, inj{SortTypeAnnotation{}, SortAnnotation{}} (From:SortTypeAnnotation{}))) [subsort{SortTypeAnnotation{}, SortAnnotation{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortParamtypeCellOpt{}, SortKItem{}} (From:SortParamtypeCellOpt{}))) [subsort{SortParamtypeCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortKCell{}, SortCell{}} (From:SortKCell{}))) [subsort{SortKCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortGroup{}, \equals{SortGroup{}, R} (Val:SortGroup{}, inj{SortPreconditionGroup{}, SortGroup{}} (From:SortPreconditionGroup{}))) [subsort{SortPreconditionGroup{}, SortGroup{}}()] // subsort + axiom{R} \exists{R} (Val:SortTraceCellOpt{}, \equals{SortTraceCellOpt{}, R} (Val:SortTraceCellOpt{}, inj{SortTraceCell{}, SortTraceCellOpt{}} (From:SortTraceCell{}))) [subsort{SortTraceCell{}, SortTraceCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortMapLiteral{}, SortKItem{}} (From:SortMapLiteral{}))) [subsort{SortMapLiteral{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortMyamountCell{}, SortKItem{}} (From:SortMyamountCell{}))) [subsort{SortMyamountCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortMapEntryList{}, \equals{SortMapEntryList{}, R} (Val:SortMapEntryList{}, inj{SortMapEntry{}, SortMapEntryList{}} (From:SortMapEntry{}))) [subsort{SortMapEntry{}, SortMapEntryList{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortInt{}, SortKItem{}} (From:SortInt{}))) [subsort{SortInt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortPreconditionGroup{}, SortKItem{}} (From:SortPreconditionGroup{}))) [subsort{SortPreconditionGroup{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortMapEntryList{}, SortKItem{}} (From:SortMapEntryList{}))) [subsort{SortMapEntryList{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortInputstackCell{}, SortCell{}} (From:SortInputstackCell{}))) [subsort{SortInputstackCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortSimpleData{}, \equals{SortSimpleData{}, R} (Val:SortSimpleData{}, inj{SortInt{}, SortSimpleData{}} (From:SortInt{}))) [subsort{SortInt{}, SortSimpleData{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortGeneratedTopCellFragment{}, SortKItem{}} (From:SortGeneratedTopCellFragment{}))) [subsort{SortGeneratedTopCellFragment{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortSequenceData{}, SortKItem{}} (From:SortSequenceData{}))) [subsort{SortSequenceData{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortInvsCellOpt{}, SortKItem{}} (From:SortInvsCellOpt{}))) [subsort{SortInvsCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortStackCellOpt{}, \equals{SortStackCellOpt{}, R} (Val:SortStackCellOpt{}, inj{SortStackCell{}, SortStackCellOpt{}} (From:SortStackCell{}))) [subsort{SortStackCell{}, SortStackCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortUnifiedList{}, \equals{SortUnifiedList{}, R} (Val:SortUnifiedList{}, inj{SortList{}, SortUnifiedList{}} (From:SortList{}))) [subsort{SortList{}, SortUnifiedList{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortMichelsonTopCell{}, SortKItem{}} (From:SortMichelsonTopCell{}))) [subsort{SortMichelsonTopCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortPgm{}, SortKItem{}} (From:SortPgm{}))) [subsort{SortPgm{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortNumTypeName{}, SortKItem{}} (From:SortNumTypeName{}))) [subsort{SortNumTypeName{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortSimpleData{}, \equals{SortSimpleData{}, R} (Val:SortSimpleData{}, inj{SortList{}, SortSimpleData{}} (From:SortList{}))) [subsort{SortList{}, SortSimpleData{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortTraceCell{}, SortCell{}} (From:SortTraceCell{}))) [subsort{SortTraceCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortInvsCellOpt{}, \equals{SortInvsCellOpt{}, R} (Val:SortInvsCellOpt{}, inj{SortInvsCell{}, SortInvsCellOpt{}} (From:SortInvsCell{}))) [subsort{SortInvsCell{}, SortInvsCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortMBytes{}, \equals{SortMBytes{}, R} (Val:SortMBytes{}, inj{SortMBytesLiteral{}, SortMBytes{}} (From:SortMBytesLiteral{}))) [subsort{SortMBytesLiteral{}, SortMBytes{}}()] // subsort + axiom{R} \exists{R} (Val:SortPostCellOpt{}, \equals{SortPostCellOpt{}, R} (Val:SortPostCellOpt{}, inj{SortPostCell{}, SortPostCellOpt{}} (From:SortPostCell{}))) [subsort{SortPostCell{}, SortPostCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortMichelsonBool{}, SortKItem{}} (From:SortMichelsonBool{}))) [subsort{SortMichelsonBool{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortPgm{}, \equals{SortPgm{}, R} (Val:SortPgm{}, inj{SortGroups{}, SortPgm{}} (From:SortGroups{}))) [subsort{SortGroups{}, SortPgm{}}()] // subsort + axiom{R} \exists{R} (Val:SortScriptCellOpt{}, \equals{SortScriptCellOpt{}, R} (Val:SortScriptCellOpt{}, inj{SortScriptCell{}, SortScriptCellOpt{}} (From:SortScriptCell{}))) [subsort{SortScriptCell{}, SortScriptCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortMybalanceCellOpt{}, \equals{SortMybalanceCellOpt{}, R} (Val:SortMybalanceCellOpt{}, inj{SortMybalanceCell{}, SortMybalanceCellOpt{}} (From:SortMybalanceCell{}))) [subsort{SortMybalanceCell{}, SortMybalanceCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortMybalanceCell{}, SortCell{}} (From:SortMybalanceCell{}))) [subsort{SortMybalanceCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortReturncodeCell{}, SortCell{}} (From:SortReturncodeCell{}))) [subsort{SortReturncodeCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortMap{}, SortKItem{}} (From:SortMap{}))) [subsort{SortMap{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortGroup{}, \equals{SortGroup{}, R} (Val:SortGroup{}, inj{SortAmountGroup{}, SortGroup{}} (From:SortAmountGroup{}))) [subsort{SortAmountGroup{}, SortGroup{}}()] // subsort + axiom{R} \exists{R} (Val:SortSequenceData{}, \equals{SortSequenceData{}, R} (Val:SortSequenceData{}, inj{SortBlock{}, SortSequenceData{}} (From:SortBlock{}))) [subsort{SortBlock{}, SortSequenceData{}}()] // subsort + axiom{R} \exists{R} (Val:SortAssumeFailedCellOpt{}, \equals{SortAssumeFailedCellOpt{}, R} (Val:SortAssumeFailedCellOpt{}, inj{SortAssumeFailedCell{}, SortAssumeFailedCellOpt{}} (From:SortAssumeFailedCell{}))) [subsort{SortAssumeFailedCell{}, SortAssumeFailedCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortMichelsonTopCellOpt{}, SortKItem{}} (From:SortMichelsonTopCellOpt{}))) [subsort{SortMichelsonTopCellOpt{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortParameterDecl{}, SortKItem{}} (From:SortParameterDecl{}))) [subsort{SortParameterDecl{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortStackElement{}, SortKItem{}} (From:SortStackElement{}))) [subsort{SortStackElement{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortSenderaddrCell{}, SortCell{}} (From:SortSenderaddrCell{}))) [subsort{SortSenderaddrCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortSimpleData{}, \equals{SortSimpleData{}, R} (Val:SortSimpleData{}, inj{SortBool{}, SortSimpleData{}} (From:SortBool{}))) [subsort{SortBool{}, SortSimpleData{}}()] // subsort + axiom{R} \exists{R} (Val:SortIOString{}, \equals{SortIOString{}, R} (Val:SortIOString{}, inj{SortIOError{}, SortIOString{}} (From:SortIOError{}))) [subsort{SortIOError{}, SortIOString{}}()] // subsort + axiom{R} \exists{R} (Val:SortData{}, \equals{SortData{}, R} (Val:SortData{}, inj{SortList{}, SortData{}} (From:SortList{}))) [subsort{SortList{}, SortData{}}()] // subsort + axiom{R} \exists{R} (Val:SortExpectedCellOpt{}, \equals{SortExpectedCellOpt{}, R} (Val:SortExpectedCellOpt{}, inj{SortExpectedCell{}, SortExpectedCellOpt{}} (From:SortExpectedCell{}))) [subsort{SortExpectedCell{}, SortExpectedCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortSenderaddrCellOpt{}, \equals{SortSenderaddrCellOpt{}, R} (Val:SortSenderaddrCellOpt{}, inj{SortSenderaddrCell{}, SortSenderaddrCellOpt{}} (From:SortSenderaddrCell{}))) [subsort{SortSenderaddrCell{}, SortSenderaddrCellOpt{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortStoragevalueCell{}, SortCell{}} (From:SortStoragevalueCell{}))) [subsort{SortStoragevalueCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortUnaryTypeName{}, SortKItem{}} (From:SortUnaryTypeName{}))) [subsort{SortUnaryTypeName{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortStackCell{}, SortCell{}} (From:SortStackCell{}))) [subsort{SortStackCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortPostCell{}, SortCell{}} (From:SortPostCell{}))) [subsort{SortPostCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortIOFile{}, \equals{SortIOFile{}, R} (Val:SortIOFile{}, inj{SortIOError{}, SortIOFile{}} (From:SortIOError{}))) [subsort{SortIOError{}, SortIOFile{}}()] // subsort + axiom{R} \exists{R} (Val:SortData{}, \equals{SortData{}, R} (Val:SortData{}, inj{SortSimpleData{}, SortData{}} (From:SortSimpleData{}))) [subsort{SortSimpleData{}, SortData{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortStoragevalueCell{}, SortKItem{}} (From:SortStoragevalueCell{}))) [subsort{SortStoragevalueCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortSymbolsCell{}, SortCell{}} (From:SortSymbolsCell{}))) [subsort{SortSymbolsCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortGroup{}, \equals{SortGroup{}, R} (Val:SortGroup{}, inj{SortContractsGroup{}, SortGroup{}} (From:SortContractsGroup{}))) [subsort{SortContractsGroup{}, SortGroup{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortInvariantsGroup{}, SortKItem{}} (From:SortInvariantsGroup{}))) [subsort{SortInvariantsGroup{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortData{}, \equals{SortData{}, R} (Val:SortData{}, inj{SortSymbolicData{}, SortData{}} (From:SortSymbolicData{}))) [subsort{SortSymbolicData{}, SortData{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortMychainidCell{}, SortKItem{}} (From:SortMychainidCell{}))) [subsort{SortMychainidCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortGroup{}, \equals{SortGroup{}, R} (Val:SortGroup{}, inj{SortParameterValueGroup{}, SortGroup{}} (From:SortParameterValueGroup{}))) [subsort{SortParameterValueGroup{}, SortGroup{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortNonceCell{}, SortKItem{}} (From:SortNonceCell{}))) [subsort{SortNonceCell{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, inj{SortOutputStack{}, SortKItem{}} (From:SortOutputStack{}))) [subsort{SortOutputStack{}, SortKItem{}}()] // subsort + axiom{R} \exists{R} (Val:SortCell{}, \equals{SortCell{}, R} (Val:SortCell{}, inj{SortMynowCell{}, SortCell{}} (From:SortMynowCell{}))) [subsort{SortMynowCell{}, SortCell{}}()] // subsort + axiom{R} \exists{R} (Val:SortAddress{}, \equals{SortAddress{}, R} (Val:SortAddress{}, Lbl'Hash'Address'LParUndsRParUnds'MICHELSON-COMMON'Unds'Address'Unds'String{}(K0:SortString{}))) [functional{}()] // functional + axiom{}\implies{SortAddress{}} (\and{SortAddress{}} (Lbl'Hash'Address'LParUndsRParUnds'MICHELSON-COMMON'Unds'Address'Unds'String{}(X0:SortString{}), Lbl'Hash'Address'LParUndsRParUnds'MICHELSON-COMMON'Unds'Address'Unds'String{}(Y0:SortString{})), Lbl'Hash'Address'LParUndsRParUnds'MICHELSON-COMMON'Unds'Address'Unds'String{}(\and{SortString{}} (X0:SortString{}, Y0:SortString{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'Hash'AllTypesKnown'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'Set{}(K0:SortSet{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortData{}, \equals{SortData{}, R} (Val:SortData{}, Lbl'Hash'Any'Unds'UNIT-TEST-COMMON-SYNTAX'Unds'Data{}())) [functional{}()] // functional + axiom{}\not{SortData{}} (\and{SortData{}} (Lbl'Hash'Any'Unds'UNIT-TEST-COMMON-SYNTAX'Unds'Data{}(), Lbl'Hash'MakeFresh'LParUndsRParUnds'MICHELSON'Unds'Data'Unds'Type{}(Y0:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortData{}} (\and{SortData{}} (Lbl'Hash'Any'Unds'UNIT-TEST-COMMON-SYNTAX'Unds'Data{}(), Lbl'Hash'hole'Unds'MICHELSON'Unds'Data{}())) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(K0:SortBoolExp{}))) [functional{}()] // functional + axiom{}\implies{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(Y0:SortBoolExp{})), Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(\and{SortBoolExp{}} (X0:SortBoolExp{}, Y0:SortBoolExp{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'AssertFailed{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(Y0:SortBoolExp{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(Y0:SortSequenceData{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(Y0:SortInternalStack{}, Y1:SortInternalStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'ConvertBigMapsToNative'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'ConvertParamToNative'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'ConvertStorageToNative'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(Y0:SortSymbolicData{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(Y0:SortUnifiedList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'CreateSymbols'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'ExecutePostConditions'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'ExecutePreConditions'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'ExecuteScript'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(Y0:SortStackElementList{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'Init'Unds'MICHELSON-CONFIG'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'LoadDefaultContractStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'LoadInputStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(Y0:SortMap{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'freezer'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'freezer'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'systemResult{}(Y0:SortInt{}, Y1:SortString{}, Y2:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, Lbl'Hash'AssertFailed{}())) [functional{}()] // functional + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'AssertFailed{}(), Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(Y0:SortBoolExp{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'AssertFailed{}(), Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(Y0:SortSequenceData{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'AssertFailed{}(), Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(Y0:SortInternalStack{}, Y1:SortInternalStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'AssertFailed{}(), Lbl'Hash'ConvertBigMapsToNative'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'AssertFailed{}(), Lbl'Hash'ConvertParamToNative'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'AssertFailed{}(), Lbl'Hash'ConvertStorageToNative'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'AssertFailed{}(), Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(Y0:SortSymbolicData{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'AssertFailed{}(), Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(Y0:SortUnifiedList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'AssertFailed{}(), Lbl'Hash'CreateSymbols'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'AssertFailed{}(), Lbl'Hash'ExecutePostConditions'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'AssertFailed{}(), Lbl'Hash'ExecutePreConditions'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'AssertFailed{}(), Lbl'Hash'ExecuteScript'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'AssertFailed{}(), Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(Y0:SortStackElementList{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'AssertFailed{}(), Lbl'Hash'Init'Unds'MICHELSON-CONFIG'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'AssertFailed{}(), Lbl'Hash'LoadDefaultContractStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'AssertFailed{}(), Lbl'Hash'LoadInputStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'AssertFailed{}(), Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(Y0:SortMap{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'AssertFailed{}(), Lbl'Hash'freezer'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'AssertFailed{}(), Lbl'Hash'freezer'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'AssertFailed{}(), Lbl'Hash'systemResult{}(Y0:SortInt{}, Y1:SortString{}, Y2:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}())) [functional{}()] // functional + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(Y0:SortMapOpInfo{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(Y0:SortTypeName{}, Y1:SortMaybeTypeName{}, Y2:SortList{}, Y3:SortList{}, Y4:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(Y0:SortData{}, Y1:SortMapOpInfo{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(Y0:SortTypeName{}, Y1:SortMaybeTypeName{}, Y2:SortList{}, Y3:SortList{}, Y4:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(Y0:SortTypeName{}, Y1:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(Y0:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(Y0:SortMutez{}, Y1:SortInt{}, Y2:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(Y0:SortOutputStack{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(K0:SortBoolExp{}))) [functional{}()] // functional + axiom{}\implies{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(Y0:SortBoolExp{})), Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(\and{SortBoolExp{}} (X0:SortBoolExp{}, Y0:SortBoolExp{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(Y0:SortSequenceData{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(Y0:SortInternalStack{}, Y1:SortInternalStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'ConvertBigMapsToNative'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'ConvertParamToNative'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'ConvertStorageToNative'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(Y0:SortSymbolicData{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(Y0:SortUnifiedList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'CreateSymbols'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'ExecutePostConditions'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'ExecutePreConditions'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'ExecuteScript'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(Y0:SortStackElementList{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'Init'Unds'MICHELSON-CONFIG'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'LoadDefaultContractStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'LoadInputStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(Y0:SortMap{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'freezer'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'freezer'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{}), Lbl'Hash'systemResult{}(Y0:SortInt{}, Y1:SortString{}, Y2:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}())) [functional{}()] // functional + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(Y0:SortMapOpInfo{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(Y0:SortTypeName{}, Y1:SortMaybeTypeName{}, Y2:SortList{}, Y3:SortList{}, Y4:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(Y0:SortData{}, Y1:SortMapOpInfo{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(Y0:SortTypeName{}, Y1:SortMaybeTypeName{}, Y2:SortList{}, Y3:SortList{}, Y4:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(Y0:SortTypeName{}, Y1:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(Y0:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(Y0:SortMutez{}, Y1:SortInt{}, Y2:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(Y0:SortOutputStack{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(K0:SortSequenceData{}, K1:SortType{}))) [functional{}()] // functional + axiom{}\implies{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(X0:SortSequenceData{}, X1:SortType{}), Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(Y0:SortSequenceData{}, Y1:SortType{})), Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(\and{SortSequenceData{}} (X0:SortSequenceData{}, Y0:SortSequenceData{}), \and{SortType{}} (X1:SortType{}, Y1:SortType{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(X0:SortSequenceData{}, X1:SortType{}), Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(Y0:SortInternalStack{}, Y1:SortInternalStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(X0:SortSequenceData{}, X1:SortType{}), Lbl'Hash'ConvertBigMapsToNative'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(X0:SortSequenceData{}, X1:SortType{}), Lbl'Hash'ConvertParamToNative'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(X0:SortSequenceData{}, X1:SortType{}), Lbl'Hash'ConvertStorageToNative'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(X0:SortSequenceData{}, X1:SortType{}), Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(Y0:SortSymbolicData{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(X0:SortSequenceData{}, X1:SortType{}), Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(Y0:SortUnifiedList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(X0:SortSequenceData{}, X1:SortType{}), Lbl'Hash'CreateSymbols'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(X0:SortSequenceData{}, X1:SortType{}), Lbl'Hash'ExecutePostConditions'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(X0:SortSequenceData{}, X1:SortType{}), Lbl'Hash'ExecutePreConditions'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(X0:SortSequenceData{}, X1:SortType{}), Lbl'Hash'ExecuteScript'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(X0:SortSequenceData{}, X1:SortType{}), Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(Y0:SortStackElementList{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(X0:SortSequenceData{}, X1:SortType{}), Lbl'Hash'Init'Unds'MICHELSON-CONFIG'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(X0:SortSequenceData{}, X1:SortType{}), Lbl'Hash'LoadDefaultContractStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(X0:SortSequenceData{}, X1:SortType{}), Lbl'Hash'LoadInputStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(X0:SortSequenceData{}, X1:SortType{}), Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(Y0:SortMap{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(X0:SortSequenceData{}, X1:SortType{}), Lbl'Hash'freezer'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(X0:SortSequenceData{}, X1:SortType{}), Lbl'Hash'freezer'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(X0:SortSequenceData{}, X1:SortType{}), Lbl'Hash'systemResult{}(Y0:SortInt{}, Y1:SortString{}, Y2:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(K0:SortInternalStack{}, K1:SortInternalStack{}))) [functional{}()] // functional + axiom{}\implies{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(X0:SortInternalStack{}, X1:SortInternalStack{}), Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(Y0:SortInternalStack{}, Y1:SortInternalStack{})), Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(\and{SortInternalStack{}} (X0:SortInternalStack{}, Y0:SortInternalStack{}), \and{SortInternalStack{}} (X1:SortInternalStack{}, Y1:SortInternalStack{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(X0:SortInternalStack{}, X1:SortInternalStack{}), Lbl'Hash'ConvertBigMapsToNative'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(X0:SortInternalStack{}, X1:SortInternalStack{}), Lbl'Hash'ConvertParamToNative'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(X0:SortInternalStack{}, X1:SortInternalStack{}), Lbl'Hash'ConvertStorageToNative'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(X0:SortInternalStack{}, X1:SortInternalStack{}), Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(Y0:SortSymbolicData{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(X0:SortInternalStack{}, X1:SortInternalStack{}), Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(Y0:SortUnifiedList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(X0:SortInternalStack{}, X1:SortInternalStack{}), Lbl'Hash'CreateSymbols'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(X0:SortInternalStack{}, X1:SortInternalStack{}), Lbl'Hash'ExecutePostConditions'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(X0:SortInternalStack{}, X1:SortInternalStack{}), Lbl'Hash'ExecutePreConditions'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(X0:SortInternalStack{}, X1:SortInternalStack{}), Lbl'Hash'ExecuteScript'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(X0:SortInternalStack{}, X1:SortInternalStack{}), Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(Y0:SortStackElementList{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(X0:SortInternalStack{}, X1:SortInternalStack{}), Lbl'Hash'Init'Unds'MICHELSON-CONFIG'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(X0:SortInternalStack{}, X1:SortInternalStack{}), Lbl'Hash'LoadDefaultContractStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(X0:SortInternalStack{}, X1:SortInternalStack{}), Lbl'Hash'LoadInputStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(X0:SortInternalStack{}, X1:SortInternalStack{}), Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(Y0:SortMap{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(X0:SortInternalStack{}, X1:SortInternalStack{}), Lbl'Hash'freezer'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(X0:SortInternalStack{}, X1:SortInternalStack{}), Lbl'Hash'freezer'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(X0:SortInternalStack{}, X1:SortInternalStack{}), Lbl'Hash'systemResult{}(Y0:SortInt{}, Y1:SortString{}, Y2:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortMBytes{}, \equals{SortMBytes{}, R} (Val:SortMBytes{}, Lbl'Hash'Blake2B'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(K0:SortMBytes{}))) [functional{}()] // functional + axiom{}\implies{SortMBytes{}} (\and{SortMBytes{}} (Lbl'Hash'Blake2B'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(X0:SortMBytes{}), Lbl'Hash'Blake2B'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(Y0:SortMBytes{})), Lbl'Hash'Blake2B'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(\and{SortMBytes{}} (X0:SortMBytes{}, Y0:SortMBytes{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortMBytes{}} (\and{SortMBytes{}} (Lbl'Hash'Blake2B'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(X0:SortMBytes{}), Lbl'Hash'Packed'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'TypeName'Unds'Data{}(Y0:SortTypeName{}, Y1:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortMBytes{}} (\and{SortMBytes{}} (Lbl'Hash'Blake2B'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(X0:SortMBytes{}), Lbl'Hash'SHA256'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(Y0:SortMBytes{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortMBytes{}} (\and{SortMBytes{}} (Lbl'Hash'Blake2B'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(X0:SortMBytes{}), Lbl'Hash'SHA512'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(Y0:SortMBytes{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortMBytes{}} (\and{SortMBytes{}} (Lbl'Hash'Blake2B'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(X0:SortMBytes{}), Lbl'Hash'SignedMBytes'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'MBytes'Unds'Key'Unds'Signature'Unds'MBytes{}(Y0:SortKey{}, Y1:SortSignature{}, Y2:SortMBytes{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortChainId{}, \equals{SortChainId{}, R} (Val:SortChainId{}, Lbl'Hash'ChainId'LParUndsRParUnds'MICHELSON-COMMON'Unds'ChainId'Unds'MBytes{}(K0:SortMBytes{}))) [functional{}()] // functional + axiom{}\implies{SortChainId{}} (\and{SortChainId{}} (Lbl'Hash'ChainId'LParUndsRParUnds'MICHELSON-COMMON'Unds'ChainId'Unds'MBytes{}(X0:SortMBytes{}), Lbl'Hash'ChainId'LParUndsRParUnds'MICHELSON-COMMON'Unds'ChainId'Unds'MBytes{}(Y0:SortMBytes{})), Lbl'Hash'ChainId'LParUndsRParUnds'MICHELSON-COMMON'Unds'ChainId'Unds'MBytes{}(\and{SortMBytes{}} (X0:SortMBytes{}, Y0:SortMBytes{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortContractData{}, \equals{SortContractData{}, R} (Val:SortContractData{}, Lbl'Hash'Contract'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'ContractData'Unds'Address'Unds'Type{}(K0:SortAddress{}, K1:SortType{}))) [functional{}()] // functional + axiom{}\implies{SortContractData{}} (\and{SortContractData{}} (Lbl'Hash'Contract'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'ContractData'Unds'Address'Unds'Type{}(X0:SortAddress{}, X1:SortType{}), Lbl'Hash'Contract'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'ContractData'Unds'Address'Unds'Type{}(Y0:SortAddress{}, Y1:SortType{})), Lbl'Hash'Contract'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'ContractData'Unds'Address'Unds'Type{}(\and{SortAddress{}} (X0:SortAddress{}, Y0:SortAddress{}), \and{SortType{}} (X1:SortType{}, Y1:SortType{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, Lbl'Hash'ConvertBigMapsToNative'Unds'MICHELSON'Unds'KItem{}())) [functional{}()] // functional + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertBigMapsToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'ConvertParamToNative'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertBigMapsToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'ConvertStorageToNative'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertBigMapsToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(Y0:SortSymbolicData{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertBigMapsToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(Y0:SortUnifiedList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertBigMapsToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'CreateSymbols'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertBigMapsToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'ExecutePostConditions'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertBigMapsToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'ExecutePreConditions'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertBigMapsToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'ExecuteScript'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertBigMapsToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(Y0:SortStackElementList{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertBigMapsToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'Init'Unds'MICHELSON-CONFIG'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertBigMapsToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'LoadDefaultContractStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertBigMapsToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'LoadInputStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertBigMapsToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(Y0:SortMap{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertBigMapsToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'freezer'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertBigMapsToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'freezer'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertBigMapsToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'systemResult{}(Y0:SortInt{}, Y1:SortString{}, Y2:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, Lbl'Hash'ConvertParamToNative'Unds'MICHELSON'Unds'KItem{}())) [functional{}()] // functional + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertParamToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'ConvertStorageToNative'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertParamToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(Y0:SortSymbolicData{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertParamToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(Y0:SortUnifiedList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertParamToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'CreateSymbols'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertParamToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'ExecutePostConditions'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertParamToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'ExecutePreConditions'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertParamToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'ExecuteScript'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertParamToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(Y0:SortStackElementList{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertParamToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'Init'Unds'MICHELSON-CONFIG'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertParamToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'LoadDefaultContractStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertParamToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'LoadInputStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertParamToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(Y0:SortMap{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertParamToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'freezer'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertParamToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'freezer'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertParamToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'systemResult{}(Y0:SortInt{}, Y1:SortString{}, Y2:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, Lbl'Hash'ConvertStorageToNative'Unds'MICHELSON'Unds'KItem{}())) [functional{}()] // functional + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertStorageToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(Y0:SortSymbolicData{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertStorageToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(Y0:SortUnifiedList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertStorageToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'CreateSymbols'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertStorageToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'ExecutePostConditions'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertStorageToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'ExecutePreConditions'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertStorageToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'ExecuteScript'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertStorageToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(Y0:SortStackElementList{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertStorageToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'Init'Unds'MICHELSON-CONFIG'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertStorageToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'LoadDefaultContractStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertStorageToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'LoadInputStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertStorageToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(Y0:SortMap{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertStorageToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'freezer'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertStorageToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'freezer'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ConvertStorageToNative'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'systemResult{}(Y0:SortInt{}, Y1:SortString{}, Y2:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(K0:SortSymbolicData{}, K1:SortType{}))) [functional{}()] // functional + axiom{}\implies{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(X0:SortSymbolicData{}, X1:SortType{}), Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(Y0:SortSymbolicData{}, Y1:SortType{})), Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(\and{SortSymbolicData{}} (X0:SortSymbolicData{}, Y0:SortSymbolicData{}), \and{SortType{}} (X1:SortType{}, Y1:SortType{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(X0:SortSymbolicData{}, X1:SortType{}), Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(Y0:SortUnifiedList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(X0:SortSymbolicData{}, X1:SortType{}), Lbl'Hash'CreateSymbols'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(X0:SortSymbolicData{}, X1:SortType{}), Lbl'Hash'ExecutePostConditions'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(X0:SortSymbolicData{}, X1:SortType{}), Lbl'Hash'ExecutePreConditions'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(X0:SortSymbolicData{}, X1:SortType{}), Lbl'Hash'ExecuteScript'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(X0:SortSymbolicData{}, X1:SortType{}), Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(Y0:SortStackElementList{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(X0:SortSymbolicData{}, X1:SortType{}), Lbl'Hash'Init'Unds'MICHELSON-CONFIG'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(X0:SortSymbolicData{}, X1:SortType{}), Lbl'Hash'LoadDefaultContractStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(X0:SortSymbolicData{}, X1:SortType{}), Lbl'Hash'LoadInputStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(X0:SortSymbolicData{}, X1:SortType{}), Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(Y0:SortMap{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(X0:SortSymbolicData{}, X1:SortType{}), Lbl'Hash'freezer'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(X0:SortSymbolicData{}, X1:SortType{}), Lbl'Hash'freezer'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(X0:SortSymbolicData{}, X1:SortType{}), Lbl'Hash'systemResult{}(Y0:SortInt{}, Y1:SortString{}, Y2:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(K0:SortUnifiedList{}))) [functional{}()] // functional + axiom{}\implies{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(X0:SortUnifiedList{}), Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(Y0:SortUnifiedList{})), Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(\and{SortUnifiedList{}} (X0:SortUnifiedList{}, Y0:SortUnifiedList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(X0:SortUnifiedList{}), Lbl'Hash'CreateSymbols'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(X0:SortUnifiedList{}), Lbl'Hash'ExecutePostConditions'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(X0:SortUnifiedList{}), Lbl'Hash'ExecutePreConditions'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(X0:SortUnifiedList{}), Lbl'Hash'ExecuteScript'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(X0:SortUnifiedList{}), Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(Y0:SortStackElementList{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(X0:SortUnifiedList{}), Lbl'Hash'Init'Unds'MICHELSON-CONFIG'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(X0:SortUnifiedList{}), Lbl'Hash'LoadDefaultContractStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(X0:SortUnifiedList{}), Lbl'Hash'LoadInputStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(X0:SortUnifiedList{}), Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(Y0:SortMap{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(X0:SortUnifiedList{}), Lbl'Hash'freezer'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(X0:SortUnifiedList{}), Lbl'Hash'freezer'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(X0:SortUnifiedList{}), Lbl'Hash'systemResult{}(Y0:SortInt{}, Y1:SortString{}, Y2:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, Lbl'Hash'CreateSymbols'Unds'MICHELSON'Unds'KItem{}())) [functional{}()] // functional + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbols'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'ExecutePostConditions'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbols'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'ExecutePreConditions'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbols'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'ExecuteScript'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbols'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(Y0:SortStackElementList{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbols'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'Init'Unds'MICHELSON-CONFIG'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbols'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'LoadDefaultContractStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbols'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'LoadInputStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbols'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(Y0:SortMap{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbols'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'freezer'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbols'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'freezer'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'CreateSymbols'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'systemResult{}(Y0:SortInt{}, Y1:SortString{}, Y2:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInt{}, \equals{SortInt{}, R} (Val:SortInt{}, Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(K0:SortData{}, K1:SortData{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(K0:SortMapOpInfo{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(Y0:SortMapOpInfo{})), Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(\and{SortMapOpInfo{}} (X0:SortMapOpInfo{}, Y0:SortMapOpInfo{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(Y0:SortTypeName{}, Y1:SortMaybeTypeName{}, Y2:SortList{}, Y3:SortList{}, Y4:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(Y0:SortData{}, Y1:SortMapOpInfo{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(Y0:SortTypeName{}, Y1:SortMaybeTypeName{}, Y2:SortList{}, Y3:SortList{}, Y4:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(Y0:SortTypeName{}, Y1:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(Y0:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(Y0:SortMutez{}, Y1:SortInt{}, Y2:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(Y0:SortOutputStack{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(K0:SortTypeName{}, K1:SortMaybeTypeName{}, K2:SortList{}, K3:SortList{}, K4:SortBlock{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(Y0:SortTypeName{}, Y1:SortMaybeTypeName{}, Y2:SortList{}, Y3:SortList{}, Y4:SortBlock{})), Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(\and{SortTypeName{}} (X0:SortTypeName{}, Y0:SortTypeName{}), \and{SortMaybeTypeName{}} (X1:SortMaybeTypeName{}, Y1:SortMaybeTypeName{}), \and{SortList{}} (X2:SortList{}, Y2:SortList{}), \and{SortList{}} (X3:SortList{}, Y3:SortList{}), \and{SortBlock{}} (X4:SortBlock{}, Y4:SortBlock{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(Y0:SortData{}, Y1:SortMapOpInfo{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(Y0:SortTypeName{}, Y1:SortMaybeTypeName{}, Y2:SortList{}, Y3:SortList{}, Y4:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(Y0:SortTypeName{}, Y1:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(Y0:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(Y0:SortMutez{}, Y1:SortInt{}, Y2:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(Y0:SortOutputStack{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(K0:SortData{}, K1:SortMapOpInfo{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(Y0:SortData{}, Y1:SortMapOpInfo{})), Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(\and{SortData{}} (X0:SortData{}, Y0:SortData{}), \and{SortMapOpInfo{}} (X1:SortMapOpInfo{}, Y1:SortMapOpInfo{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(Y0:SortTypeName{}, Y1:SortMaybeTypeName{}, Y2:SortList{}, Y3:SortList{}, Y4:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(Y0:SortTypeName{}, Y1:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(Y0:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(Y0:SortMutez{}, Y1:SortInt{}, Y2:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(Y0:SortOutputStack{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(K0:SortTypeName{}, K1:SortMaybeTypeName{}, K2:SortList{}, K3:SortList{}, K4:SortBlock{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(Y0:SortTypeName{}, Y1:SortMaybeTypeName{}, Y2:SortList{}, Y3:SortList{}, Y4:SortBlock{})), Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(\and{SortTypeName{}} (X0:SortTypeName{}, Y0:SortTypeName{}), \and{SortMaybeTypeName{}} (X1:SortMaybeTypeName{}, Y1:SortMaybeTypeName{}), \and{SortList{}} (X2:SortList{}, Y2:SortList{}), \and{SortList{}} (X3:SortList{}, Y3:SortList{}), \and{SortBlock{}} (X4:SortBlock{}, Y4:SortBlock{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(Y0:SortTypeName{}, Y1:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(Y0:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(Y0:SortMutez{}, Y1:SortInt{}, Y2:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(Y0:SortOutputStack{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'E2BIG{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EACCES{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EADDRINUSE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EADDRNOTAVAIL{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EAFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EAGAIN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EALREADY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EBADF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EBUSY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ECHILD{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ECONNABORTED{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ECONNREFUSED{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ECONNRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EDEADLK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EDESTADDRREQ{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EDOM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EEXIST{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EFAULT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EFBIG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EHOSTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EHOSTUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EINPROGRESS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EINTR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EINVAL{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EISCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EISDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'E2BIG{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EACCES{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EADDRINUSE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EADDRNOTAVAIL{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EAFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EAGAIN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EALREADY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EBADF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EBUSY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ECHILD{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ECONNABORTED{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ECONNREFUSED{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ECONNRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EDEADLK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EDESTADDRREQ{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EDOM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EEXIST{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EFAULT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EFBIG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EHOSTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EHOSTUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EINPROGRESS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EINTR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EINVAL{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EISCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EISDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EACCES{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EADDRINUSE{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EADDRNOTAVAIL{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EAFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EAGAIN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EALREADY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EBADF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EBUSY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ECHILD{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ECONNABORTED{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ECONNREFUSED{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ECONNRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EDEADLK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EDESTADDRREQ{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EDOM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EEXIST{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EFAULT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EFBIG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EHOSTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EHOSTUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EINPROGRESS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EINTR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EINVAL{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EISCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EISDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EADDRNOTAVAIL{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EAFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EAGAIN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EALREADY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EBADF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EBUSY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ECHILD{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ECONNABORTED{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ECONNREFUSED{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ECONNRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EDEADLK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EDESTADDRREQ{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EDOM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EEXIST{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EFAULT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EFBIG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EHOSTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EHOSTUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EINPROGRESS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EINTR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EINVAL{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EISCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EISDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EAFNOSUPPORT{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EAGAIN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EALREADY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EBADF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EBUSY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ECHILD{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ECONNABORTED{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ECONNREFUSED{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ECONNRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EDEADLK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EDESTADDRREQ{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EDOM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EEXIST{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EFAULT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EFBIG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EHOSTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EHOSTUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EINPROGRESS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EINTR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EINVAL{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EISCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EISDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EAGAIN{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EALREADY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EBADF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EBUSY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ECHILD{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ECONNABORTED{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ECONNREFUSED{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ECONNRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EDEADLK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EDESTADDRREQ{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EDOM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EEXIST{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EFAULT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EFBIG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EHOSTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EHOSTUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EINPROGRESS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EINTR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EINVAL{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EISCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EISDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EAGAIN{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EALREADY{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EBADF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EBUSY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ECHILD{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ECONNABORTED{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ECONNREFUSED{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ECONNRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EDEADLK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EDESTADDRREQ{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EDOM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EEXIST{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EFAULT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EFBIG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EHOSTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EHOSTUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EINPROGRESS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EINTR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EINVAL{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EISCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EISDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EALREADY{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EBADF{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EBUSY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ECHILD{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ECONNABORTED{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ECONNREFUSED{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ECONNRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EDEADLK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EDESTADDRREQ{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EDOM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EEXIST{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EFAULT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EFBIG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EHOSTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EHOSTUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EINPROGRESS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EINTR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EINVAL{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EISCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EISDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBADF{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EBUSY{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ECHILD{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ECONNABORTED{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ECONNREFUSED{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ECONNRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EDEADLK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EDESTADDRREQ{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EDOM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EEXIST{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EFAULT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EFBIG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EHOSTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EHOSTUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EINPROGRESS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EINTR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EINVAL{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EISCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EISDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EBUSY{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ECHILD{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ECONNABORTED{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ECONNREFUSED{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ECONNRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EDEADLK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EDESTADDRREQ{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EDOM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EEXIST{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EFAULT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EFBIG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EHOSTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EHOSTUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EINPROGRESS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EINTR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EINVAL{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EISCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EISDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECHILD{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ECONNABORTED{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ECONNREFUSED{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ECONNRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EDEADLK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EDESTADDRREQ{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EDOM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EEXIST{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EFAULT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EFBIG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EHOSTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EHOSTUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EINPROGRESS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EINTR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EINVAL{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EISCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EISDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ECONNREFUSED{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ECONNRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EDEADLK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EDESTADDRREQ{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EDOM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EEXIST{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EFAULT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EFBIG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EHOSTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EHOSTUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EINPROGRESS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EINTR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EINVAL{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EISCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EISDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ECONNRESET{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EDEADLK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EDESTADDRREQ{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EDOM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EEXIST{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EFAULT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EFBIG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EHOSTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EHOSTUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EINPROGRESS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EINTR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EINVAL{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EISCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EISDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EDEADLK{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EDESTADDRREQ{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EDOM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EEXIST{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EFAULT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EFBIG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EHOSTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EHOSTUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EINPROGRESS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EINTR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EINVAL{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EISCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EISDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDEADLK{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EDESTADDRREQ{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'EDOM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'EEXIST{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'EFAULT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'EFBIG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'EHOSTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'EHOSTUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'EINPROGRESS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'EINTR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'EINVAL{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'EIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'EISCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'EISDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EDOM{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'EEXIST{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'EFAULT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'EFBIG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'EHOSTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'EHOSTUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'EINPROGRESS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'EINTR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'EINVAL{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'EIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'EISCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'EISDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EDOM{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EEXIST{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'EFAULT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'EFBIG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'EHOSTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'EHOSTUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'EINPROGRESS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'EINTR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'EINVAL{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'EIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'EISCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'EISDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EEXIST{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EFAULT{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'EFBIG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'EHOSTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'EHOSTUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'EINPROGRESS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'EINTR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'EINVAL{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'EIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'EISCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'EISDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFAULT{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EFBIG{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'EHOSTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'EHOSTUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'EINPROGRESS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'EINTR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'EINVAL{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'EIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'EISCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'EISDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EFBIG{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EHOSTDOWN{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'EHOSTUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'EINPROGRESS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'EINTR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'EINVAL{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'EIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'EISCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'EISDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EHOSTUNREACH{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'EINPROGRESS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'EINTR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'EINVAL{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'EIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'EISCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'EISDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EINPROGRESS{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'EINTR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'EINVAL{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'EIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'EISCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'EISDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EINTR{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'EINVAL{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'EIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'EISCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'EISDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINTR{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EINVAL{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'EIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'EISCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'EISDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EINVAL{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EIO{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'EISCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'EISDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EIO{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EISCONN{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'EISDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISCONN{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EISDIR{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ELOOP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EISDIR{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ELOOP{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'EMFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ELOOP{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EMFILE{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'EMLINK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMFILE{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EMLINK{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'EMSGSIZE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMLINK{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EMSGSIZE{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ENAMETOOLONG{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ENAMETOOLONG{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'ENETDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ENETDOWN{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'ENETRESET{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ENETRESET{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'ENETUNREACH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETRESET{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ENETUNREACH{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'ENFILE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ENFILE{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'ENOBUFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENFILE{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ENOBUFS{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'ENODEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ENODEV{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'ENOENT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENODEV{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ENOENT{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'ENOEXEC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOENT{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ENOEXEC{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'ENOLCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ENOLCK{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'ENOMEM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOLCK{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ENOMEM{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'ENOPROTOOPT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOMEM{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ENOPROTOOPT{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'ENOSPC{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ENOSPC{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSPC{}(), Lbl'Hash'ENOSYS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSPC{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSPC{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSPC{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSPC{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSPC{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSPC{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSPC{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSPC{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSPC{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSPC{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSPC{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSPC{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSPC{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSPC{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSPC{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSPC{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSPC{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSPC{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSPC{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSPC{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSPC{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSPC{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSPC{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSPC{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSPC{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ENOSYS{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSYS{}(), Lbl'Hash'ENOTCONN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSYS{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSYS{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSYS{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSYS{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSYS{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSYS{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSYS{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSYS{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSYS{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSYS{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSYS{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSYS{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSYS{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSYS{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSYS{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSYS{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSYS{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSYS{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSYS{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSYS{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSYS{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSYS{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSYS{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOSYS{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ENOTCONN{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTCONN{}(), Lbl'Hash'ENOTDIR{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTCONN{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTCONN{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTCONN{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTCONN{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTCONN{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTCONN{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTCONN{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTCONN{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTCONN{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTCONN{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTCONN{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTCONN{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTCONN{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTCONN{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTCONN{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTCONN{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTCONN{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTCONN{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTCONN{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTCONN{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTCONN{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTCONN{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTCONN{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ENOTDIR{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTDIR{}(), Lbl'Hash'ENOTEMPTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTDIR{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTDIR{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTDIR{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTDIR{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTDIR{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTDIR{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTDIR{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTDIR{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTDIR{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTDIR{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTDIR{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTDIR{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTDIR{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTDIR{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTDIR{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTDIR{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTDIR{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTDIR{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTDIR{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTDIR{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTDIR{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTDIR{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ENOTEMPTY{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTEMPTY{}(), Lbl'Hash'ENOTSOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTEMPTY{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTEMPTY{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTEMPTY{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTEMPTY{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTEMPTY{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTEMPTY{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTEMPTY{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTEMPTY{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTEMPTY{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTEMPTY{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTEMPTY{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTEMPTY{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTEMPTY{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTEMPTY{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTEMPTY{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTEMPTY{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTEMPTY{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTEMPTY{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTEMPTY{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTEMPTY{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTEMPTY{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ENOTSOCK{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTSOCK{}(), Lbl'Hash'ENOTTY{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTSOCK{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTSOCK{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTSOCK{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTSOCK{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTSOCK{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTSOCK{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTSOCK{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTSOCK{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTSOCK{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTSOCK{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTSOCK{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTSOCK{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTSOCK{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTSOCK{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTSOCK{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTSOCK{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTSOCK{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTSOCK{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTSOCK{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTSOCK{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ENOTTY{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTTY{}(), Lbl'Hash'ENXIO{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTTY{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTTY{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTTY{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTTY{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTTY{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTTY{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTTY{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTTY{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTTY{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTTY{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTTY{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTTY{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTTY{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTTY{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTTY{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTTY{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTTY{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTTY{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENOTTY{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ENXIO{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENXIO{}(), Lbl'Hash'EOF{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENXIO{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENXIO{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENXIO{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENXIO{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENXIO{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENXIO{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENXIO{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENXIO{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENXIO{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENXIO{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENXIO{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENXIO{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENXIO{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENXIO{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENXIO{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENXIO{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENXIO{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ENXIO{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EOF{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOF{}(), Lbl'Hash'EOPNOTSUPP{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOF{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOF{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOF{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOF{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOF{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOF{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOF{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOF{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOF{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOF{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOF{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOF{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOF{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOF{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOF{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOF{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOF{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EOPNOTSUPP{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOPNOTSUPP{}(), Lbl'Hash'EOVERFLOW{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOPNOTSUPP{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOPNOTSUPP{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOPNOTSUPP{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOPNOTSUPP{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOPNOTSUPP{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOPNOTSUPP{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOPNOTSUPP{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOPNOTSUPP{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOPNOTSUPP{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOPNOTSUPP{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOPNOTSUPP{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOPNOTSUPP{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOPNOTSUPP{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOPNOTSUPP{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOPNOTSUPP{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOPNOTSUPP{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EOVERFLOW{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOVERFLOW{}(), Lbl'Hash'EPERM{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOVERFLOW{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOVERFLOW{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOVERFLOW{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOVERFLOW{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOVERFLOW{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOVERFLOW{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOVERFLOW{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOVERFLOW{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOVERFLOW{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOVERFLOW{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOVERFLOW{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOVERFLOW{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOVERFLOW{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOVERFLOW{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EOVERFLOW{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EPERM{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPERM{}(), Lbl'Hash'EPFNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPERM{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPERM{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPERM{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPERM{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPERM{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPERM{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPERM{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPERM{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPERM{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPERM{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPERM{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPERM{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPERM{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPERM{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EPFNOSUPPORT{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPFNOSUPPORT{}(), Lbl'Hash'EPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPFNOSUPPORT{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPFNOSUPPORT{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPFNOSUPPORT{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPFNOSUPPORT{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPFNOSUPPORT{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPFNOSUPPORT{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPFNOSUPPORT{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPFNOSUPPORT{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPFNOSUPPORT{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPFNOSUPPORT{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPFNOSUPPORT{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPFNOSUPPORT{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPFNOSUPPORT{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EPIPE{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPIPE{}(), Lbl'Hash'EPROTONOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPIPE{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPIPE{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPIPE{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPIPE{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPIPE{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPIPE{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPIPE{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPIPE{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPIPE{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPIPE{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPIPE{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPIPE{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EPROTONOSUPPORT{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPROTONOSUPPORT{}(), Lbl'Hash'EPROTOTYPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPROTONOSUPPORT{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPROTONOSUPPORT{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPROTONOSUPPORT{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPROTONOSUPPORT{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPROTONOSUPPORT{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPROTONOSUPPORT{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPROTONOSUPPORT{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPROTONOSUPPORT{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPROTONOSUPPORT{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPROTONOSUPPORT{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPROTONOSUPPORT{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EPROTOTYPE{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPROTOTYPE{}(), Lbl'Hash'ERANGE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPROTOTYPE{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPROTOTYPE{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPROTOTYPE{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPROTOTYPE{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPROTOTYPE{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPROTOTYPE{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPROTOTYPE{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPROTOTYPE{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPROTOTYPE{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EPROTOTYPE{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ERANGE{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ERANGE{}(), Lbl'Hash'EROFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ERANGE{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ERANGE{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ERANGE{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ERANGE{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ERANGE{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ERANGE{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ERANGE{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ERANGE{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ERANGE{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EROFS{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EROFS{}(), Lbl'Hash'ESHUTDOWN{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EROFS{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EROFS{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EROFS{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EROFS{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EROFS{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EROFS{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EROFS{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EROFS{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ESHUTDOWN{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ESHUTDOWN{}(), Lbl'Hash'ESOCKTNOSUPPORT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ESHUTDOWN{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ESHUTDOWN{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ESHUTDOWN{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ESHUTDOWN{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ESHUTDOWN{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ESHUTDOWN{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ESHUTDOWN{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ESOCKTNOSUPPORT{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ESOCKTNOSUPPORT{}(), Lbl'Hash'ESPIPE{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ESOCKTNOSUPPORT{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ESOCKTNOSUPPORT{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ESOCKTNOSUPPORT{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ESOCKTNOSUPPORT{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ESOCKTNOSUPPORT{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ESOCKTNOSUPPORT{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ESPIPE{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ESPIPE{}(), Lbl'Hash'ESRCH{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ESPIPE{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ESPIPE{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ESPIPE{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ESPIPE{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ESPIPE{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ESRCH{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ESRCH{}(), Lbl'Hash'ETIMEDOUT{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ESRCH{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ESRCH{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ESRCH{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ESRCH{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ETIMEDOUT{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ETIMEDOUT{}(), Lbl'Hash'ETOOMANYREFS{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ETIMEDOUT{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ETIMEDOUT{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ETIMEDOUT{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'ETOOMANYREFS{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ETOOMANYREFS{}(), Lbl'Hash'EWOULDBLOCK{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ETOOMANYREFS{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'ETOOMANYREFS{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EWOULDBLOCK{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EWOULDBLOCK{}(), Lbl'Hash'EXDEV{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EWOULDBLOCK{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'EXDEV{}())) [functional{}()] // functional + axiom{}\not{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'EXDEV{}(), Lbl'Hash'unknownIOError{}(Y0:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, Lbl'Hash'ExecutePostConditions'Unds'MICHELSON'Unds'KItem{}())) [functional{}()] // functional + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecutePostConditions'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'ExecutePreConditions'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecutePostConditions'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'ExecuteScript'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecutePostConditions'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(Y0:SortStackElementList{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecutePostConditions'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'Init'Unds'MICHELSON-CONFIG'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecutePostConditions'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'LoadDefaultContractStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecutePostConditions'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'LoadInputStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecutePostConditions'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(Y0:SortMap{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecutePostConditions'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'freezer'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecutePostConditions'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'freezer'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecutePostConditions'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'systemResult{}(Y0:SortInt{}, Y1:SortString{}, Y2:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, Lbl'Hash'ExecutePreConditions'Unds'MICHELSON'Unds'KItem{}())) [functional{}()] // functional + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecutePreConditions'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'ExecuteScript'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecutePreConditions'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(Y0:SortStackElementList{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecutePreConditions'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'Init'Unds'MICHELSON-CONFIG'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecutePreConditions'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'LoadDefaultContractStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecutePreConditions'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'LoadInputStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecutePreConditions'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(Y0:SortMap{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecutePreConditions'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'freezer'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecutePreConditions'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'freezer'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecutePreConditions'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'systemResult{}(Y0:SortInt{}, Y1:SortString{}, Y2:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, Lbl'Hash'ExecuteScript'Unds'MICHELSON'Unds'KItem{}())) [functional{}()] // functional + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecuteScript'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(Y0:SortStackElementList{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecuteScript'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'Init'Unds'MICHELSON-CONFIG'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecuteScript'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'LoadDefaultContractStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecuteScript'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'LoadInputStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecuteScript'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(Y0:SortMap{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecuteScript'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'freezer'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecuteScript'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'freezer'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'ExecuteScript'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'systemResult{}(Y0:SortInt{}, Y1:SortString{}, Y2:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortSet{}, \equals{SortSet{}, R} (Val:SortSet{}, Lbl'Hash'FindSymbolsB'LParUndsRParUnds'MICHELSON'Unds'Set'Unds'Block{}(K0:SortBlock{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortSet{}, \equals{SortSet{}, R} (Val:SortSet{}, Lbl'Hash'FindSymbolsBL'LParUndsRParUnds'MICHELSON'Unds'Set'Unds'BlockList{}(K0:SortBlockList{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortSet{}, \equals{SortSet{}, R} (Val:SortSet{}, Lbl'Hash'FindSymbolsI'LParUndsRParUnds'MICHELSON'Unds'Set'Unds'Instruction{}(K0:SortInstruction{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortSet{}, \equals{SortSet{}, R} (Val:SortSet{}, Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(K0:SortData{}, K1:SortType{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortSet{}, \equals{SortSet{}, R} (Val:SortSet{}, Lbl'Hash'FindSymbolsS'LParUndsRParUnds'MICHELSON'Unds'Set'Unds'StackElementList{}(K0:SortStackElementList{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(K0:SortStackElementList{}, K1:SortStack{}))) [functional{}()] // functional + axiom{}\implies{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(X0:SortStackElementList{}, X1:SortStack{}), Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(Y0:SortStackElementList{}, Y1:SortStack{})), Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(\and{SortStackElementList{}} (X0:SortStackElementList{}, Y0:SortStackElementList{}), \and{SortStack{}} (X1:SortStack{}, Y1:SortStack{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(X0:SortStackElementList{}, X1:SortStack{}), Lbl'Hash'Init'Unds'MICHELSON-CONFIG'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(X0:SortStackElementList{}, X1:SortStack{}), Lbl'Hash'LoadDefaultContractStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(X0:SortStackElementList{}, X1:SortStack{}), Lbl'Hash'LoadInputStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(X0:SortStackElementList{}, X1:SortStack{}), Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(Y0:SortMap{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(X0:SortStackElementList{}, X1:SortStack{}), Lbl'Hash'freezer'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(X0:SortStackElementList{}, X1:SortStack{}), Lbl'Hash'freezer'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(X0:SortStackElementList{}, X1:SortStack{}), Lbl'Hash'systemResult{}(Y0:SortInt{}, Y1:SortString{}, Y2:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(Y0:SortTypeName{}, Y1:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(Y0:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(Y0:SortMutez{}, Y1:SortInt{}, Y2:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(Y0:SortOutputStack{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, Lbl'Hash'Init'Unds'MICHELSON-CONFIG'Unds'KItem{}())) [functional{}()] // functional + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Init'Unds'MICHELSON-CONFIG'Unds'KItem{}(), Lbl'Hash'LoadDefaultContractStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Init'Unds'MICHELSON-CONFIG'Unds'KItem{}(), Lbl'Hash'LoadInputStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Init'Unds'MICHELSON-CONFIG'Unds'KItem{}(), Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(Y0:SortMap{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Init'Unds'MICHELSON-CONFIG'Unds'KItem{}(), Lbl'Hash'freezer'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Init'Unds'MICHELSON-CONFIG'Unds'KItem{}(), Lbl'Hash'freezer'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'Init'Unds'MICHELSON-CONFIG'Unds'KItem{}(), Lbl'Hash'systemResult{}(Y0:SortInt{}, Y1:SortString{}, Y2:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'Hash'IsComparable'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName{}(K0:SortTypeName{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortKey{}, \equals{SortKey{}, R} (Val:SortKey{}, Lbl'Hash'Key'LParUndsRParUnds'MICHELSON-COMMON'Unds'Key'Unds'String{}(K0:SortString{}))) [functional{}()] // functional + axiom{}\implies{SortKey{}} (\and{SortKey{}} (Lbl'Hash'Key'LParUndsRParUnds'MICHELSON-COMMON'Unds'Key'Unds'String{}(X0:SortString{}), Lbl'Hash'Key'LParUndsRParUnds'MICHELSON-COMMON'Unds'Key'Unds'String{}(Y0:SortString{})), Lbl'Hash'Key'LParUndsRParUnds'MICHELSON-COMMON'Unds'Key'Unds'String{}(\and{SortString{}} (X0:SortString{}, Y0:SortString{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortKeyHash{}, \equals{SortKeyHash{}, R} (Val:SortKeyHash{}, Lbl'Hash'KeyHash'LParUndsRParUnds'MICHELSON-COMMON'Unds'KeyHash'Unds'String{}(K0:SortString{}))) [functional{}()] // functional + axiom{}\implies{SortKeyHash{}} (\and{SortKeyHash{}} (Lbl'Hash'KeyHash'LParUndsRParUnds'MICHELSON-COMMON'Unds'KeyHash'Unds'String{}(X0:SortString{}), Lbl'Hash'KeyHash'LParUndsRParUnds'MICHELSON-COMMON'Unds'KeyHash'Unds'String{}(Y0:SortString{})), Lbl'Hash'KeyHash'LParUndsRParUnds'MICHELSON-COMMON'Unds'KeyHash'Unds'String{}(\and{SortString{}} (X0:SortString{}, Y0:SortString{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortLambdaData{}, \equals{SortLambdaData{}, R} (Val:SortLambdaData{}, Lbl'Hash'Lambda'LParUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'LambdaData'Unds'TypeName'Unds'TypeName'Unds'Block{}(K0:SortTypeName{}, K1:SortTypeName{}, K2:SortBlock{}))) [functional{}()] // functional + axiom{}\implies{SortLambdaData{}} (\and{SortLambdaData{}} (Lbl'Hash'Lambda'LParUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'LambdaData'Unds'TypeName'Unds'TypeName'Unds'Block{}(X0:SortTypeName{}, X1:SortTypeName{}, X2:SortBlock{}), Lbl'Hash'Lambda'LParUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'LambdaData'Unds'TypeName'Unds'TypeName'Unds'Block{}(Y0:SortTypeName{}, Y1:SortTypeName{}, Y2:SortBlock{})), Lbl'Hash'Lambda'LParUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'LambdaData'Unds'TypeName'Unds'TypeName'Unds'Block{}(\and{SortTypeName{}} (X0:SortTypeName{}, Y0:SortTypeName{}), \and{SortTypeName{}} (X1:SortTypeName{}, Y1:SortTypeName{}), \and{SortBlock{}} (X2:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, Lbl'Hash'LoadDefaultContractStack'Unds'MICHELSON'Unds'KItem{}())) [functional{}()] // functional + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'LoadDefaultContractStack'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'LoadInputStack'Unds'MICHELSON'Unds'KItem{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'LoadDefaultContractStack'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(Y0:SortMap{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'LoadDefaultContractStack'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'freezer'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'LoadDefaultContractStack'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'freezer'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'LoadDefaultContractStack'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'systemResult{}(Y0:SortInt{}, Y1:SortString{}, Y2:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, Lbl'Hash'LoadInputStack'Unds'MICHELSON'Unds'KItem{}())) [functional{}()] // functional + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'LoadInputStack'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(Y0:SortMap{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'LoadInputStack'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'freezer'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'LoadInputStack'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'freezer'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'LoadInputStack'Unds'MICHELSON'Unds'KItem{}(), Lbl'Hash'systemResult{}(Y0:SortInt{}, Y1:SortString{}, Y2:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortData{}, \equals{SortData{}, R} (Val:SortData{}, Lbl'Hash'MakeFresh'LParUndsRParUnds'MICHELSON'Unds'Data'Unds'Type{}(K0:SortType{}))) [functional{}()] // functional + axiom{}\implies{SortData{}} (\and{SortData{}} (Lbl'Hash'MakeFresh'LParUndsRParUnds'MICHELSON'Unds'Data'Unds'Type{}(X0:SortType{}), Lbl'Hash'MakeFresh'LParUndsRParUnds'MICHELSON'Unds'Data'Unds'Type{}(Y0:SortType{})), Lbl'Hash'MakeFresh'LParUndsRParUnds'MICHELSON'Unds'Data'Unds'Type{}(\and{SortType{}} (X0:SortType{}, Y0:SortType{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortData{}} (\and{SortData{}} (Lbl'Hash'MakeFresh'LParUndsRParUnds'MICHELSON'Unds'Data'Unds'Type{}(X0:SortType{}), Lbl'Hash'hole'Unds'MICHELSON'Unds'Data{}())) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortMapOpInfo{}, \equals{SortMapOpInfo{}, R} (Val:SortMapOpInfo{}, Lbl'Hash'MapOpInfo'LParUndsCommUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'MapOpInfo'Unds'TypeName'Unds'TypeName'Unds'MaybeTypeName'Unds'Map'Unds'Map'Unds'Block{}(K0:SortTypeName{}, K1:SortTypeName{}, K2:SortMaybeTypeName{}, K3:SortMap{}, K4:SortMap{}, K5:SortBlock{}))) [functional{}()] // functional + axiom{}\implies{SortMapOpInfo{}} (\and{SortMapOpInfo{}} (Lbl'Hash'MapOpInfo'LParUndsCommUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'MapOpInfo'Unds'TypeName'Unds'TypeName'Unds'MaybeTypeName'Unds'Map'Unds'Map'Unds'Block{}(X0:SortTypeName{}, X1:SortTypeName{}, X2:SortMaybeTypeName{}, X3:SortMap{}, X4:SortMap{}, X5:SortBlock{}), Lbl'Hash'MapOpInfo'LParUndsCommUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'MapOpInfo'Unds'TypeName'Unds'TypeName'Unds'MaybeTypeName'Unds'Map'Unds'Map'Unds'Block{}(Y0:SortTypeName{}, Y1:SortTypeName{}, Y2:SortMaybeTypeName{}, Y3:SortMap{}, Y4:SortMap{}, Y5:SortBlock{})), Lbl'Hash'MapOpInfo'LParUndsCommUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'MapOpInfo'Unds'TypeName'Unds'TypeName'Unds'MaybeTypeName'Unds'Map'Unds'Map'Unds'Block{}(\and{SortTypeName{}} (X0:SortTypeName{}, Y0:SortTypeName{}), \and{SortTypeName{}} (X1:SortTypeName{}, Y1:SortTypeName{}), \and{SortMaybeTypeName{}} (X2:SortMaybeTypeName{}, Y2:SortMaybeTypeName{}), \and{SortMap{}} (X3:SortMap{}, Y3:SortMap{}), \and{SortMap{}} (X4:SortMap{}, Y4:SortMap{}), \and{SortBlock{}} (X5:SortBlock{}, Y5:SortBlock{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortMutez{}, \equals{SortMutez{}, R} (Val:SortMutez{}, Lbl'Hash'Mutez'LParUndsRParUnds'MICHELSON-COMMON'Unds'Mutez'Unds'Int{}(K0:SortInt{}))) [functional{}()] // functional + axiom{}\implies{SortMutez{}} (\and{SortMutez{}} (Lbl'Hash'Mutez'LParUndsRParUnds'MICHELSON-COMMON'Unds'Mutez'Unds'Int{}(X0:SortInt{}), Lbl'Hash'Mutez'LParUndsRParUnds'MICHELSON-COMMON'Unds'Mutez'Unds'Int{}(Y0:SortInt{})), Lbl'Hash'Mutez'LParUndsRParUnds'MICHELSON-COMMON'Unds'Mutez'Unds'Int{}(\and{SortInt{}} (X0:SortInt{}, Y0:SortInt{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortTypeName{}, \equals{SortTypeName{}, R} (Val:SortTypeName{}, Lbl'Hash'Name'LParUndsRParUnds'MICHELSON-COMMON'Unds'TypeName'Unds'Type{}(K0:SortType{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortPreData{}, \equals{SortPreData{}, R} (Val:SortPreData{}, Lbl'Hash'NoData'Unds'MICHELSON-COMMON'Unds'PreData{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortOperationNonce{}, \equals{SortOperationNonce{}, R} (Val:SortOperationNonce{}, Lbl'Hash'Nonce'LParUndsRParUnds'MICHELSON-COMMON'Unds'OperationNonce'Unds'Int{}(K0:SortInt{}))) [functional{}()] // functional + axiom{}\implies{SortOperationNonce{}} (\and{SortOperationNonce{}} (Lbl'Hash'Nonce'LParUndsRParUnds'MICHELSON-COMMON'Unds'OperationNonce'Unds'Int{}(X0:SortInt{}), Lbl'Hash'Nonce'LParUndsRParUnds'MICHELSON-COMMON'Unds'OperationNonce'Unds'Int{}(Y0:SortInt{})), Lbl'Hash'Nonce'LParUndsRParUnds'MICHELSON-COMMON'Unds'OperationNonce'Unds'Int{}(\and{SortInt{}} (X0:SortInt{}, Y0:SortInt{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'Hash'NotEq'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName'Unds'Data'Unds'Data{}(K0:SortTypeName{}, K1:SortData{}, K2:SortData{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortPreType{}, \equals{SortPreType{}, R} (Val:SortPreType{}, Lbl'Hash'NotSet'Unds'MICHELSON-COMMON'Unds'PreType{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortMBytes{}, \equals{SortMBytes{}, R} (Val:SortMBytes{}, Lbl'Hash'Packed'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'TypeName'Unds'Data{}(K0:SortTypeName{}, K1:SortData{}))) [functional{}()] // functional + axiom{}\implies{SortMBytes{}} (\and{SortMBytes{}} (Lbl'Hash'Packed'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), Lbl'Hash'Packed'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'TypeName'Unds'Data{}(Y0:SortTypeName{}, Y1:SortData{})), Lbl'Hash'Packed'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'TypeName'Unds'Data{}(\and{SortTypeName{}} (X0:SortTypeName{}, Y0:SortTypeName{}), \and{SortData{}} (X1:SortData{}, Y1:SortData{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortMBytes{}} (\and{SortMBytes{}} (Lbl'Hash'Packed'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), Lbl'Hash'SHA256'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(Y0:SortMBytes{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortMBytes{}} (\and{SortMBytes{}} (Lbl'Hash'Packed'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), Lbl'Hash'SHA512'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(Y0:SortMBytes{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortMBytes{}} (\and{SortMBytes{}} (Lbl'Hash'Packed'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), Lbl'Hash'SignedMBytes'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'MBytes'Unds'Key'Unds'Signature'Unds'MBytes{}(Y0:SortKey{}, Y1:SortSignature{}, Y2:SortMBytes{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(K0:SortTypeName{}, K1:SortData{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(Y0:SortTypeName{}, Y1:SortData{})), Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(\and{SortTypeName{}} (X0:SortTypeName{}, Y0:SortTypeName{}), \and{SortData{}} (X1:SortData{}, Y1:SortData{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(Y0:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(Y0:SortMutez{}, Y1:SortInt{}, Y2:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(Y0:SortOutputStack{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(K0:SortK{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{})), Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(\and{SortK{}} (X0:SortK{}, Y0:SortK{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(Y0:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(Y0:SortMutez{}, Y1:SortInt{}, Y2:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(Y0:SortOutputStack{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(K0:SortMap{}))) [functional{}()] // functional + axiom{}\implies{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(X0:SortMap{}), Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(Y0:SortMap{})), Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(\and{SortMap{}} (X0:SortMap{}, Y0:SortMap{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(X0:SortMap{}), Lbl'Hash'freezer'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(X0:SortMap{}), Lbl'Hash'freezer'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(X0:SortMap{}), Lbl'Hash'systemResult{}(Y0:SortInt{}, Y1:SortString{}, Y2:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(K0:SortStack{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(Y0:SortStack{})), Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(\and{SortStack{}} (X0:SortStack{}, Y0:SortStack{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(Y0:SortMutez{}, Y1:SortInt{}, Y2:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(Y0:SortOutputStack{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortMBytes{}, \equals{SortMBytes{}, R} (Val:SortMBytes{}, Lbl'Hash'SHA256'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(K0:SortMBytes{}))) [functional{}()] // functional + axiom{}\implies{SortMBytes{}} (\and{SortMBytes{}} (Lbl'Hash'SHA256'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(X0:SortMBytes{}), Lbl'Hash'SHA256'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(Y0:SortMBytes{})), Lbl'Hash'SHA256'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(\and{SortMBytes{}} (X0:SortMBytes{}, Y0:SortMBytes{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortMBytes{}} (\and{SortMBytes{}} (Lbl'Hash'SHA256'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(X0:SortMBytes{}), Lbl'Hash'SHA512'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(Y0:SortMBytes{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortMBytes{}} (\and{SortMBytes{}} (Lbl'Hash'SHA256'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(X0:SortMBytes{}), Lbl'Hash'SignedMBytes'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'MBytes'Unds'Key'Unds'Signature'Unds'MBytes{}(Y0:SortKey{}, Y1:SortSignature{}, Y2:SortMBytes{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortMBytes{}, \equals{SortMBytes{}, R} (Val:SortMBytes{}, Lbl'Hash'SHA512'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(K0:SortMBytes{}))) [functional{}()] // functional + axiom{}\implies{SortMBytes{}} (\and{SortMBytes{}} (Lbl'Hash'SHA512'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(X0:SortMBytes{}), Lbl'Hash'SHA512'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(Y0:SortMBytes{})), Lbl'Hash'SHA512'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(\and{SortMBytes{}} (X0:SortMBytes{}, Y0:SortMBytes{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortMBytes{}} (\and{SortMBytes{}} (Lbl'Hash'SHA512'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(X0:SortMBytes{}), Lbl'Hash'SignedMBytes'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'MBytes'Unds'Key'Unds'Signature'Unds'MBytes{}(Y0:SortKey{}, Y1:SortSignature{}, Y2:SortMBytes{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortSignature{}, \equals{SortSignature{}, R} (Val:SortSignature{}, Lbl'Hash'Signature'LParUndsRParUnds'MICHELSON-COMMON'Unds'Signature'Unds'String{}(K0:SortString{}))) [functional{}()] // functional + axiom{}\implies{SortSignature{}} (\and{SortSignature{}} (Lbl'Hash'Signature'LParUndsRParUnds'MICHELSON-COMMON'Unds'Signature'Unds'String{}(X0:SortString{}), Lbl'Hash'Signature'LParUndsRParUnds'MICHELSON-COMMON'Unds'Signature'Unds'String{}(Y0:SortString{})), Lbl'Hash'Signature'LParUndsRParUnds'MICHELSON-COMMON'Unds'Signature'Unds'String{}(\and{SortString{}} (X0:SortString{}, Y0:SortString{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortMBytes{}, \equals{SortMBytes{}, R} (Val:SortMBytes{}, Lbl'Hash'SignedMBytes'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'MBytes'Unds'Key'Unds'Signature'Unds'MBytes{}(K0:SortKey{}, K1:SortSignature{}, K2:SortMBytes{}))) [functional{}()] // functional + axiom{}\implies{SortMBytes{}} (\and{SortMBytes{}} (Lbl'Hash'SignedMBytes'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'MBytes'Unds'Key'Unds'Signature'Unds'MBytes{}(X0:SortKey{}, X1:SortSignature{}, X2:SortMBytes{}), Lbl'Hash'SignedMBytes'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'MBytes'Unds'Key'Unds'Signature'Unds'MBytes{}(Y0:SortKey{}, Y1:SortSignature{}, Y2:SortMBytes{})), Lbl'Hash'SignedMBytes'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'MBytes'Unds'Key'Unds'Signature'Unds'MBytes{}(\and{SortKey{}} (X0:SortKey{}, Y0:SortKey{}), \and{SortSignature{}} (X1:SortSignature{}, Y1:SortSignature{}), \and{SortMBytes{}} (X2:SortMBytes{}, Y2:SortMBytes{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortSymbolicElement{}, \equals{SortSymbolicElement{}, R} (Val:SortSymbolicElement{}, Lbl'Hash'SymbolicElement'LParUndsCommUndsRParUnds'MICHELSON'Unds'SymbolicElement'Unds'SymbolicData'Unds'Type{}(K0:SortSymbolicData{}, K1:SortType{}))) [functional{}()] // functional + axiom{}\implies{SortSymbolicElement{}} (\and{SortSymbolicElement{}} (Lbl'Hash'SymbolicElement'LParUndsCommUndsRParUnds'MICHELSON'Unds'SymbolicElement'Unds'SymbolicData'Unds'Type{}(X0:SortSymbolicData{}, X1:SortType{}), Lbl'Hash'SymbolicElement'LParUndsCommUndsRParUnds'MICHELSON'Unds'SymbolicElement'Unds'SymbolicData'Unds'Type{}(Y0:SortSymbolicData{}, Y1:SortType{})), Lbl'Hash'SymbolicElement'LParUndsCommUndsRParUnds'MICHELSON'Unds'SymbolicElement'Unds'SymbolicData'Unds'Type{}(\and{SortSymbolicData{}} (X0:SortSymbolicData{}, Y0:SortSymbolicData{}), \and{SortType{}} (X1:SortType{}, Y1:SortType{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortTimestamp{}, \equals{SortTimestamp{}, R} (Val:SortTimestamp{}, Lbl'Hash'Timestamp'LParUndsRParUnds'MICHELSON-COMMON'Unds'Timestamp'Unds'Int{}(K0:SortInt{}))) [functional{}()] // functional + axiom{}\implies{SortTimestamp{}} (\and{SortTimestamp{}} (Lbl'Hash'Timestamp'LParUndsRParUnds'MICHELSON-COMMON'Unds'Timestamp'Unds'Int{}(X0:SortInt{}), Lbl'Hash'Timestamp'LParUndsRParUnds'MICHELSON-COMMON'Unds'Timestamp'Unds'Int{}(Y0:SortInt{})), Lbl'Hash'Timestamp'LParUndsRParUnds'MICHELSON-COMMON'Unds'Timestamp'Unds'Int{}(\and{SortInt{}} (X0:SortInt{}, Y0:SortInt{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortType{}, \equals{SortType{}, R} (Val:SortType{}, Lbl'Hash'Type'LParUndsRParUnds'MICHELSON-COMMON'Unds'Type'Unds'TypeName{}(K0:SortTypeName{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortTypedData{}, \equals{SortTypedData{}, R} (Val:SortTypedData{}, Lbl'Hash'Typed'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'TypedData'Unds'Data'Unds'Type{}(K0:SortData{}, K1:SortType{}))) [functional{}()] // functional + axiom{}\implies{SortTypedData{}} (\and{SortTypedData{}} (Lbl'Hash'Typed'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'TypedData'Unds'Data'Unds'Type{}(X0:SortData{}, X1:SortType{}), Lbl'Hash'Typed'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'TypedData'Unds'Data'Unds'Type{}(Y0:SortData{}, Y1:SortType{})), Lbl'Hash'Typed'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'TypedData'Unds'Data'Unds'Type{}(\and{SortData{}} (X0:SortData{}, Y0:SortData{}), \and{SortType{}} (X1:SortType{}, Y1:SortType{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortTypedSymbol{}, \equals{SortTypedSymbol{}, R} (Val:SortTypedSymbol{}, Lbl'Hash'TypedSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'TypedSymbol'Unds'TypeName'Unds'Data{}(K0:SortTypeName{}, K1:SortData{}))) [functional{}()] // functional + axiom{}\implies{SortTypedSymbol{}} (\and{SortTypedSymbol{}} (Lbl'Hash'TypedSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'TypedSymbol'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), Lbl'Hash'TypedSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'TypedSymbol'Unds'TypeName'Unds'Data{}(Y0:SortTypeName{}, Y1:SortData{})), Lbl'Hash'TypedSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'TypedSymbol'Unds'TypeName'Unds'Data{}(\and{SortTypeName{}} (X0:SortTypeName{}, Y0:SortTypeName{}), \and{SortData{}} (X1:SortData{}, Y1:SortData{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortUnificationFailure{}, \equals{SortUnificationFailure{}, R} (Val:SortUnificationFailure{}, Lbl'Hash'UnificationFailure'Unds'MICHELSON'Unds'UnificationFailure{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortUnifiedList{}, \equals{SortUnifiedList{}, R} (Val:SortUnifiedList{}, Lbl'Hash'UnifiedSetToList'LParUndsRParUnds'MICHELSON'Unds'UnifiedList'Unds'UnifiedSet{}(K0:SortUnifiedSet{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortUnifiedSet{}, \equals{SortUnifiedSet{}, R} (Val:SortUnifiedSet{}, Lbl'Hash'UnifyTypes'LParUndsRParUnds'MICHELSON'Unds'UnifiedSet'Unds'Set{}(K0:SortSet{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortType{}, \equals{SortType{}, R} (Val:SortType{}, Lbl'Hash'UnknownType'Unds'MICHELSON'Unds'Type{}())) [functional{}()] // functional + axiom{}\not{SortType{}} (\and{SortType{}} (Lbl'Hash'UnknownType'Unds'MICHELSON'Unds'Type{}(), Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(Y0:SortNullaryTypeName{}, Y1:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortType{}} (\and{SortType{}} (Lbl'Hash'UnknownType'Unds'MICHELSON'Unds'Type{}(), Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Y0:SortUnaryTypeName{}, Y1:SortAnnotationList{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortType{}} (\and{SortType{}} (Lbl'Hash'UnknownType'Unds'MICHELSON'Unds'Type{}(), Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortBinaryTypeName{}, Y1:SortAnnotationList{}, Y2:SortType{}, Y3:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(K0:SortMutez{}, K1:SortInt{}, K2:SortInt{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(Y0:SortMutez{}, Y1:SortInt{}, Y2:SortInt{})), Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(\and{SortMutez{}} (X0:SortMutez{}, Y0:SortMutez{}), \and{SortInt{}} (X1:SortInt{}, Y1:SortInt{}), \and{SortInt{}} (X2:SortInt{}, Y2:SortInt{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(Y0:SortOutputStack{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortStream{}, \equals{SortStream{}, R} (Val:SortStream{}, Lbl'Hash'buffer'LParUndsRParUnds'K-IO'Unds'Stream'Unds'K{}(K0:SortK{}))) [functional{}()] // functional + axiom{}\implies{SortStream{}} (\and{SortStream{}} (Lbl'Hash'buffer'LParUndsRParUnds'K-IO'Unds'Stream'Unds'K{}(X0:SortK{}), Lbl'Hash'buffer'LParUndsRParUnds'K-IO'Unds'Stream'Unds'K{}(Y0:SortK{})), Lbl'Hash'buffer'LParUndsRParUnds'K-IO'Unds'Stream'Unds'K{}(\and{SortK{}} (X0:SortK{}, Y0:SortK{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, Lbl'Hash'freezer'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [functional{}()] // functional + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'freezer'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}(), Lbl'Hash'freezer'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'freezer'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}(), Lbl'Hash'systemResult{}(Y0:SortInt{}, Y1:SortString{}, Y2:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, Lbl'Hash'freezer'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}())) [functional{}()] // functional + axiom{}\not{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'freezer'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}(), Lbl'Hash'systemResult{}(Y0:SortInt{}, Y1:SortString{}, Y2:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortData{}, \equals{SortData{}, R} (Val:SortData{}, Lbl'Hash'hole'Unds'MICHELSON'Unds'Data{}())) [functional{}()] // functional + axiom{R, SortSort} \exists{R} (Val:SortSort, \equals{SortSort, R} (Val:SortSort, Lbl'Hash'if'UndsHash'then'UndsHash'else'UndsHash'fi'Unds'K-EQUAL-SYNTAX'Unds'Sort'Unds'Bool'Unds'Sort'Unds'Sort{SortSort}(K0:SortBool{}, K1:SortSort, K2:SortSort))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortK{}, \equals{SortK{}, R} (Val:SortK{}, Lbl'Hash'logToFile{}(K0:SortString{}, K1:SortString{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortK{}, \equals{SortK{}, R} (Val:SortK{}, Lbl'Hash'remove'LParUndsRParUnds'K-IO'Unds'K'Unds'String{}(K0:SortString{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInt{}, \equals{SortInt{}, R} (Val:SortInt{}, Lbl'Hash'stderr'Unds'K-IO'Unds'Int{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInt{}, \equals{SortInt{}, R} (Val:SortInt{}, Lbl'Hash'stdin'Unds'K-IO'Unds'Int{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInt{}, \equals{SortInt{}, R} (Val:SortInt{}, Lbl'Hash'stdout'Unds'K-IO'Unds'Int{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, Lbl'Hash'systemResult{}(K0:SortInt{}, K1:SortString{}, K2:SortString{}))) [functional{}()] // functional + axiom{}\implies{SortKItem{}} (\and{SortKItem{}} (Lbl'Hash'systemResult{}(X0:SortInt{}, X1:SortString{}, X2:SortString{}), Lbl'Hash'systemResult{}(Y0:SortInt{}, Y1:SortString{}, Y2:SortString{})), Lbl'Hash'systemResult{}(\and{SortInt{}} (X0:SortInt{}, Y0:SortInt{}), \and{SortString{}} (X1:SortString{}, Y1:SortString{}), \and{SortString{}} (X2:SortString{}, Y2:SortString{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortIOFile{}, \equals{SortIOFile{}, R} (Val:SortIOFile{}, Lbl'Hash'tempFile{}(K0:SortString{}, K1:SortInt{}))) [functional{}()] // functional + axiom{}\implies{SortIOFile{}} (\and{SortIOFile{}} (Lbl'Hash'tempFile{}(X0:SortString{}, X1:SortInt{}), Lbl'Hash'tempFile{}(Y0:SortString{}, Y1:SortInt{})), Lbl'Hash'tempFile{}(\and{SortString{}} (X0:SortString{}, Y0:SortString{}), \and{SortInt{}} (X1:SortInt{}, Y1:SortInt{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortIOError{}, \equals{SortIOError{}, R} (Val:SortIOError{}, Lbl'Hash'unknownIOError{}(K0:SortInt{}))) [functional{}()] // functional + axiom{}\implies{SortIOError{}} (\and{SortIOError{}} (Lbl'Hash'unknownIOError{}(X0:SortInt{}), Lbl'Hash'unknownIOError{}(Y0:SortInt{})), Lbl'Hash'unknownIOError{}(\and{SortInt{}} (X0:SortInt{}, Y0:SortInt{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortFailedStack{}, \equals{SortFailedStack{}, R} (Val:SortFailedStack{}, Lbl'LPar'Failed'UndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Data{}(K0:SortData{}))) [functional{}()] // functional + axiom{}\implies{SortFailedStack{}} (\and{SortFailedStack{}} (Lbl'LPar'Failed'UndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Data{}(X0:SortData{}), Lbl'LPar'Failed'UndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Data{}(Y0:SortData{})), Lbl'LPar'Failed'UndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Data{}(\and{SortData{}} (X0:SortData{}, Y0:SortData{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortFailedStack{}} (\and{SortFailedStack{}} (Lbl'LPar'Failed'UndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Data{}(X0:SortData{}), Lbl'LPar'GeneralOverflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(Y0:SortInt{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortFailedStack{}} (\and{SortFailedStack{}} (Lbl'LPar'Failed'UndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Data{}(X0:SortData{}), Lbl'LPar'MutezOverflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(Y0:SortInt{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortFailedStack{}} (\and{SortFailedStack{}} (Lbl'LPar'Failed'UndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Data{}(X0:SortData{}), Lbl'LPar'MutezUnderflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(Y0:SortInt{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortFailedStack{}, \equals{SortFailedStack{}, R} (Val:SortFailedStack{}, Lbl'LPar'GeneralOverflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(K0:SortInt{}, K1:SortInt{}))) [functional{}()] // functional + axiom{}\implies{SortFailedStack{}} (\and{SortFailedStack{}} (Lbl'LPar'GeneralOverflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(X0:SortInt{}, X1:SortInt{}), Lbl'LPar'GeneralOverflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(Y0:SortInt{}, Y1:SortInt{})), Lbl'LPar'GeneralOverflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(\and{SortInt{}} (X0:SortInt{}, Y0:SortInt{}), \and{SortInt{}} (X1:SortInt{}, Y1:SortInt{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortFailedStack{}} (\and{SortFailedStack{}} (Lbl'LPar'GeneralOverflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(X0:SortInt{}, X1:SortInt{}), Lbl'LPar'MutezOverflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(Y0:SortInt{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortFailedStack{}} (\and{SortFailedStack{}} (Lbl'LPar'GeneralOverflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(X0:SortInt{}, X1:SortInt{}), Lbl'LPar'MutezUnderflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(Y0:SortInt{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortFailedStack{}, \equals{SortFailedStack{}, R} (Val:SortFailedStack{}, Lbl'LPar'MutezOverflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(K0:SortInt{}, K1:SortInt{}))) [functional{}()] // functional + axiom{}\implies{SortFailedStack{}} (\and{SortFailedStack{}} (Lbl'LPar'MutezOverflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(X0:SortInt{}, X1:SortInt{}), Lbl'LPar'MutezOverflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(Y0:SortInt{}, Y1:SortInt{})), Lbl'LPar'MutezOverflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(\and{SortInt{}} (X0:SortInt{}, Y0:SortInt{}), \and{SortInt{}} (X1:SortInt{}, Y1:SortInt{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortFailedStack{}} (\and{SortFailedStack{}} (Lbl'LPar'MutezOverflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(X0:SortInt{}, X1:SortInt{}), Lbl'LPar'MutezUnderflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(Y0:SortInt{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortFailedStack{}, \equals{SortFailedStack{}, R} (Val:SortFailedStack{}, Lbl'LPar'MutezUnderflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(K0:SortInt{}, K1:SortInt{}))) [functional{}()] // functional + axiom{}\implies{SortFailedStack{}} (\and{SortFailedStack{}} (Lbl'LPar'MutezUnderflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(X0:SortInt{}, X1:SortInt{}), Lbl'LPar'MutezUnderflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(Y0:SortInt{}, Y1:SortInt{})), Lbl'LPar'MutezUnderflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(\and{SortInt{}} (X0:SortInt{}, Y0:SortInt{}), \and{SortInt{}} (X1:SortInt{}, Y1:SortInt{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortBytes{}, \equals{SortBytes{}, R} (Val:SortBytes{}, Lbl'Stop'Bytes'Unds'BYTES-HOOKED'Unds'Bytes{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortList{}, \equals{SortList{}, R} (Val:SortList{}, Lbl'Stop'List{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBigMapEntryList{}, \equals{SortBigMapEntryList{}, R} (Val:SortBigMapEntryList{}, Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntryList'Unds'BigMapEntry'Unds'BigMapEntryList'QuotRBraUnds'BigMapEntryList{}())) [functional{}()] // functional + axiom{}\not{SortBigMapEntryList{}} (\and{SortBigMapEntryList{}} (Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntryList'Unds'BigMapEntry'Unds'BigMapEntryList'QuotRBraUnds'BigMapEntryList{}(), Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntryList'Unds'BigMapEntry'Unds'BigMapEntryList{}(Y0:SortBigMapEntry{}, Y1:SortBigMapEntryList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortOtherContractsMapEntryList{}, \equals{SortOtherContractsMapEntryList{}, R} (Val:SortOtherContractsMapEntryList{}, Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OtherContractsMapEntryList'Unds'OtherContractsMapEntry'Unds'OtherContractsMapEntryList'QuotRBraUnds'OtherContractsMapEntryList{}())) [functional{}()] // functional + axiom{}\not{SortOtherContractsMapEntryList{}} (\and{SortOtherContractsMapEntryList{}} (Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OtherContractsMapEntryList'Unds'OtherContractsMapEntry'Unds'OtherContractsMapEntryList'QuotRBraUnds'OtherContractsMapEntryList{}(), Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OtherContractsMapEntryList'Unds'OtherContractsMapEntry'Unds'OtherContractsMapEntryList{}(Y0:SortOtherContractsMapEntry{}, Y1:SortOtherContractsMapEntryList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortStack{}, \equals{SortStack{}, R} (Val:SortStack{}, Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack'QuotRBraUnds'Stack{}())) [functional{}()] // functional + axiom{}\not{SortStack{}} (\and{SortStack{}} (Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack'QuotRBraUnds'Stack{}(), Lbl'UndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack{}(Y0:SortStackElement{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortBlockList{}, \equals{SortBlockList{}, R} (Val:SortBlockList{}, Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockList'Unds'Block'Unds'BlockList'QuotRBraUnds'BlockList{}())) [functional{}()] // functional + axiom{}\not{SortBlockList{}} (\and{SortBlockList{}} (Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockList'Unds'Block'Unds'BlockList'QuotRBraUnds'BlockList{}(), Lbl'UndsSClnUndsUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockList'Unds'Block'Unds'BlockList{}(Y0:SortBlock{}, Y1:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortStackElementList{}, \equals{SortStackElementList{}, R} (Val:SortStackElementList{}, Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'StackElementList'Unds'StackElementLiteral'Unds'StackElementList'QuotRBraUnds'StackElementList{}())) [functional{}()] // functional + axiom{}\not{SortStackElementList{}} (\and{SortStackElementList{}} (Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'StackElementList'Unds'StackElementLiteral'Unds'StackElementList'QuotRBraUnds'StackElementList{}(), Lbl'UndsSClnUndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'StackElementList'Unds'StackElementLiteral'Unds'StackElementList{}(Y0:SortStackElementLiteral{}, Y1:SortStackElementList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortAnnotationList{}, \equals{SortAnnotationList{}, R} (Val:SortAnnotationList{}, Lbl'Stop'List'LBraQuotUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList'QuotRBraUnds'AnnotationList{}())) [functional{}()] // functional + axiom{}\not{SortAnnotationList{}} (\and{SortAnnotationList{}} (Lbl'Stop'List'LBraQuotUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList'QuotRBraUnds'AnnotationList{}(), Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList{}(Y0:SortAnnotation{}, Y1:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortMap{}, \equals{SortMap{}, R} (Val:SortMap{}, Lbl'Stop'Map{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortSet{}, \equals{SortSet{}, R} (Val:SortSet{}, Lbl'Stop'Set{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortAssumeFailedCell{}, \equals{SortAssumeFailedCell{}, R} (Val:SortAssumeFailedCell{}, Lbl'-LT-'assumeFailed'-GT-'{}(K0:SortBool{}))) [functional{}()] // functional + axiom{}\implies{SortAssumeFailedCell{}} (\and{SortAssumeFailedCell{}} (Lbl'-LT-'assumeFailed'-GT-'{}(X0:SortBool{}), Lbl'-LT-'assumeFailed'-GT-'{}(Y0:SortBool{})), Lbl'-LT-'assumeFailed'-GT-'{}(\and{SortBool{}} (X0:SortBool{}, Y0:SortBool{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortBigmapsCell{}, \equals{SortBigmapsCell{}, R} (Val:SortBigmapsCell{}, Lbl'-LT-'bigmaps'-GT-'{}(K0:SortMap{}))) [functional{}()] // functional + axiom{}\implies{SortBigmapsCell{}} (\and{SortBigmapsCell{}} (Lbl'-LT-'bigmaps'-GT-'{}(X0:SortMap{}), Lbl'-LT-'bigmaps'-GT-'{}(Y0:SortMap{})), Lbl'-LT-'bigmaps'-GT-'{}(\and{SortMap{}} (X0:SortMap{}, Y0:SortMap{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortCutpointsCell{}, \equals{SortCutpointsCell{}, R} (Val:SortCutpointsCell{}, Lbl'-LT-'cutpoints'-GT-'{}(K0:SortSet{}))) [functional{}()] // functional + axiom{}\implies{SortCutpointsCell{}} (\and{SortCutpointsCell{}} (Lbl'-LT-'cutpoints'-GT-'{}(X0:SortSet{}), Lbl'-LT-'cutpoints'-GT-'{}(Y0:SortSet{})), Lbl'-LT-'cutpoints'-GT-'{}(\and{SortSet{}} (X0:SortSet{}, Y0:SortSet{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortExpectedCell{}, \equals{SortExpectedCell{}, R} (Val:SortExpectedCell{}, Lbl'-LT-'expected'-GT-'{}(K0:SortK{}))) [functional{}()] // functional + axiom{}\implies{SortExpectedCell{}} (\and{SortExpectedCell{}} (Lbl'-LT-'expected'-GT-'{}(X0:SortK{}), Lbl'-LT-'expected'-GT-'{}(Y0:SortK{})), Lbl'-LT-'expected'-GT-'{}(\and{SortK{}} (X0:SortK{}, Y0:SortK{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortGeneratedCounterCell{}, \equals{SortGeneratedCounterCell{}, R} (Val:SortGeneratedCounterCell{}, Lbl'-LT-'generatedCounter'-GT-'{}(K0:SortInt{}))) [functional{}()] // functional + axiom{}\implies{SortGeneratedCounterCell{}} (\and{SortGeneratedCounterCell{}} (Lbl'-LT-'generatedCounter'-GT-'{}(X0:SortInt{}), Lbl'-LT-'generatedCounter'-GT-'{}(Y0:SortInt{})), Lbl'-LT-'generatedCounter'-GT-'{}(\and{SortInt{}} (X0:SortInt{}, Y0:SortInt{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortGeneratedTopCell{}, \equals{SortGeneratedTopCell{}, R} (Val:SortGeneratedTopCell{}, Lbl'-LT-'generatedTop'-GT-'{}(K0:SortMichelsonTopCell{}, K1:SortGeneratedCounterCell{}))) [functional{}()] // functional + axiom{}\implies{SortGeneratedTopCell{}} (\and{SortGeneratedTopCell{}} (Lbl'-LT-'generatedTop'-GT-'{}(X0:SortMichelsonTopCell{}, X1:SortGeneratedCounterCell{}), Lbl'-LT-'generatedTop'-GT-'{}(Y0:SortMichelsonTopCell{}, Y1:SortGeneratedCounterCell{})), Lbl'-LT-'generatedTop'-GT-'{}(\and{SortMichelsonTopCell{}} (X0:SortMichelsonTopCell{}, Y0:SortMichelsonTopCell{}), \and{SortGeneratedCounterCell{}} (X1:SortGeneratedCounterCell{}, Y1:SortGeneratedCounterCell{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortGeneratedTopCellFragment{}, \equals{SortGeneratedTopCellFragment{}, R} (Val:SortGeneratedTopCellFragment{}, Lbl'-LT-'generatedTop'-GT-'-fragment{}(K0:SortMichelsonTopCellOpt{}, K1:SortGeneratedCounterCellOpt{}))) [functional{}()] // functional + axiom{}\implies{SortGeneratedTopCellFragment{}} (\and{SortGeneratedTopCellFragment{}} (Lbl'-LT-'generatedTop'-GT-'-fragment{}(X0:SortMichelsonTopCellOpt{}, X1:SortGeneratedCounterCellOpt{}), Lbl'-LT-'generatedTop'-GT-'-fragment{}(Y0:SortMichelsonTopCellOpt{}, Y1:SortGeneratedCounterCellOpt{})), Lbl'-LT-'generatedTop'-GT-'-fragment{}(\and{SortMichelsonTopCellOpt{}} (X0:SortMichelsonTopCellOpt{}, Y0:SortMichelsonTopCellOpt{}), \and{SortGeneratedCounterCellOpt{}} (X1:SortGeneratedCounterCellOpt{}, Y1:SortGeneratedCounterCellOpt{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortInputstackCell{}, \equals{SortInputstackCell{}, R} (Val:SortInputstackCell{}, Lbl'-LT-'inputstack'-GT-'{}(K0:SortK{}))) [functional{}()] // functional + axiom{}\implies{SortInputstackCell{}} (\and{SortInputstackCell{}} (Lbl'-LT-'inputstack'-GT-'{}(X0:SortK{}), Lbl'-LT-'inputstack'-GT-'{}(Y0:SortK{})), Lbl'-LT-'inputstack'-GT-'{}(\and{SortK{}} (X0:SortK{}, Y0:SortK{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortInvsCell{}, \equals{SortInvsCell{}, R} (Val:SortInvsCell{}, Lbl'-LT-'invs'-GT-'{}(K0:SortMap{}))) [functional{}()] // functional + axiom{}\implies{SortInvsCell{}} (\and{SortInvsCell{}} (Lbl'-LT-'invs'-GT-'{}(X0:SortMap{}), Lbl'-LT-'invs'-GT-'{}(Y0:SortMap{})), Lbl'-LT-'invs'-GT-'{}(\and{SortMap{}} (X0:SortMap{}, Y0:SortMap{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortKCell{}, \equals{SortKCell{}, R} (Val:SortKCell{}, Lbl'-LT-'k'-GT-'{}(K0:SortK{}))) [functional{}()] // functional + axiom{}\implies{SortKCell{}} (\and{SortKCell{}} (Lbl'-LT-'k'-GT-'{}(X0:SortK{}), Lbl'-LT-'k'-GT-'{}(Y0:SortK{})), Lbl'-LT-'k'-GT-'{}(\and{SortK{}} (X0:SortK{}, Y0:SortK{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortKnownaddrsCell{}, \equals{SortKnownaddrsCell{}, R} (Val:SortKnownaddrsCell{}, Lbl'-LT-'knownaddrs'-GT-'{}(K0:SortMap{}))) [functional{}()] // functional + axiom{}\implies{SortKnownaddrsCell{}} (\and{SortKnownaddrsCell{}} (Lbl'-LT-'knownaddrs'-GT-'{}(X0:SortMap{}), Lbl'-LT-'knownaddrs'-GT-'{}(Y0:SortMap{})), Lbl'-LT-'knownaddrs'-GT-'{}(\and{SortMap{}} (X0:SortMap{}, Y0:SortMap{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortMichelsonTopCell{}, \equals{SortMichelsonTopCell{}, R} (Val:SortMichelsonTopCell{}, Lbl'-LT-'michelsonTop'-GT-'{}(K0:SortParamtypeCell{}, K1:SortParamvalueCell{}, K2:SortStoragetypeCell{}, K3:SortStoragevalueCell{}, K4:SortMybalanceCell{}, K5:SortMyamountCell{}, K6:SortMynowCell{}, K7:SortMyaddrCell{}, K8:SortKnownaddrsCell{}, K9:SortSourceaddrCell{}, K10:SortSenderaddrCell{}, K11:SortMychainidCell{}, K12:SortNonceCell{}, K13:SortBigmapsCell{}, K14:SortScriptCell{}, K15:SortKCell{}, K16:SortStackCell{}, K17:SortInputstackCell{}, K18:SortExpectedCell{}, K19:SortPreCell{}, K20:SortPostCell{}, K21:SortInvsCell{}, K22:SortCutpointsCell{}, K23:SortSymbolsCell{}, K24:SortReturncodeCell{}, K25:SortAssumeFailedCell{}, K26:SortTraceCell{}))) [functional{}()] // functional + axiom{}\implies{SortMichelsonTopCell{}} (\and{SortMichelsonTopCell{}} (Lbl'-LT-'michelsonTop'-GT-'{}(X0:SortParamtypeCell{}, X1:SortParamvalueCell{}, X2:SortStoragetypeCell{}, X3:SortStoragevalueCell{}, X4:SortMybalanceCell{}, X5:SortMyamountCell{}, X6:SortMynowCell{}, X7:SortMyaddrCell{}, X8:SortKnownaddrsCell{}, X9:SortSourceaddrCell{}, X10:SortSenderaddrCell{}, X11:SortMychainidCell{}, X12:SortNonceCell{}, X13:SortBigmapsCell{}, X14:SortScriptCell{}, X15:SortKCell{}, X16:SortStackCell{}, X17:SortInputstackCell{}, X18:SortExpectedCell{}, X19:SortPreCell{}, X20:SortPostCell{}, X21:SortInvsCell{}, X22:SortCutpointsCell{}, X23:SortSymbolsCell{}, X24:SortReturncodeCell{}, X25:SortAssumeFailedCell{}, X26:SortTraceCell{}), Lbl'-LT-'michelsonTop'-GT-'{}(Y0:SortParamtypeCell{}, Y1:SortParamvalueCell{}, Y2:SortStoragetypeCell{}, Y3:SortStoragevalueCell{}, Y4:SortMybalanceCell{}, Y5:SortMyamountCell{}, Y6:SortMynowCell{}, Y7:SortMyaddrCell{}, Y8:SortKnownaddrsCell{}, Y9:SortSourceaddrCell{}, Y10:SortSenderaddrCell{}, Y11:SortMychainidCell{}, Y12:SortNonceCell{}, Y13:SortBigmapsCell{}, Y14:SortScriptCell{}, Y15:SortKCell{}, Y16:SortStackCell{}, Y17:SortInputstackCell{}, Y18:SortExpectedCell{}, Y19:SortPreCell{}, Y20:SortPostCell{}, Y21:SortInvsCell{}, Y22:SortCutpointsCell{}, Y23:SortSymbolsCell{}, Y24:SortReturncodeCell{}, Y25:SortAssumeFailedCell{}, Y26:SortTraceCell{})), Lbl'-LT-'michelsonTop'-GT-'{}(\and{SortParamtypeCell{}} (X0:SortParamtypeCell{}, Y0:SortParamtypeCell{}), \and{SortParamvalueCell{}} (X1:SortParamvalueCell{}, Y1:SortParamvalueCell{}), \and{SortStoragetypeCell{}} (X2:SortStoragetypeCell{}, Y2:SortStoragetypeCell{}), \and{SortStoragevalueCell{}} (X3:SortStoragevalueCell{}, Y3:SortStoragevalueCell{}), \and{SortMybalanceCell{}} (X4:SortMybalanceCell{}, Y4:SortMybalanceCell{}), \and{SortMyamountCell{}} (X5:SortMyamountCell{}, Y5:SortMyamountCell{}), \and{SortMynowCell{}} (X6:SortMynowCell{}, Y6:SortMynowCell{}), \and{SortMyaddrCell{}} (X7:SortMyaddrCell{}, Y7:SortMyaddrCell{}), \and{SortKnownaddrsCell{}} (X8:SortKnownaddrsCell{}, Y8:SortKnownaddrsCell{}), \and{SortSourceaddrCell{}} (X9:SortSourceaddrCell{}, Y9:SortSourceaddrCell{}), \and{SortSenderaddrCell{}} (X10:SortSenderaddrCell{}, Y10:SortSenderaddrCell{}), \and{SortMychainidCell{}} (X11:SortMychainidCell{}, Y11:SortMychainidCell{}), \and{SortNonceCell{}} (X12:SortNonceCell{}, Y12:SortNonceCell{}), \and{SortBigmapsCell{}} (X13:SortBigmapsCell{}, Y13:SortBigmapsCell{}), \and{SortScriptCell{}} (X14:SortScriptCell{}, Y14:SortScriptCell{}), \and{SortKCell{}} (X15:SortKCell{}, Y15:SortKCell{}), \and{SortStackCell{}} (X16:SortStackCell{}, Y16:SortStackCell{}), \and{SortInputstackCell{}} (X17:SortInputstackCell{}, Y17:SortInputstackCell{}), \and{SortExpectedCell{}} (X18:SortExpectedCell{}, Y18:SortExpectedCell{}), \and{SortPreCell{}} (X19:SortPreCell{}, Y19:SortPreCell{}), \and{SortPostCell{}} (X20:SortPostCell{}, Y20:SortPostCell{}), \and{SortInvsCell{}} (X21:SortInvsCell{}, Y21:SortInvsCell{}), \and{SortCutpointsCell{}} (X22:SortCutpointsCell{}, Y22:SortCutpointsCell{}), \and{SortSymbolsCell{}} (X23:SortSymbolsCell{}, Y23:SortSymbolsCell{}), \and{SortReturncodeCell{}} (X24:SortReturncodeCell{}, Y24:SortReturncodeCell{}), \and{SortAssumeFailedCell{}} (X25:SortAssumeFailedCell{}, Y25:SortAssumeFailedCell{}), \and{SortTraceCell{}} (X26:SortTraceCell{}, Y26:SortTraceCell{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortMichelsonTopCellFragment{}, \equals{SortMichelsonTopCellFragment{}, R} (Val:SortMichelsonTopCellFragment{}, Lbl'-LT-'michelsonTop'-GT-'-fragment{}(K0:SortParamtypeCellOpt{}, K1:SortParamvalueCellOpt{}, K2:SortStoragetypeCellOpt{}, K3:SortStoragevalueCellOpt{}, K4:SortMybalanceCellOpt{}, K5:SortMyamountCellOpt{}, K6:SortMynowCellOpt{}, K7:SortMyaddrCellOpt{}, K8:SortKnownaddrsCellOpt{}, K9:SortSourceaddrCellOpt{}, K10:SortSenderaddrCellOpt{}, K11:SortMychainidCellOpt{}, K12:SortNonceCellOpt{}, K13:SortBigmapsCellOpt{}, K14:SortScriptCellOpt{}, K15:SortKCellOpt{}, K16:SortStackCellOpt{}, K17:SortInputstackCellOpt{}, K18:SortExpectedCellOpt{}, K19:SortPreCellOpt{}, K20:SortPostCellOpt{}, K21:SortInvsCellOpt{}, K22:SortCutpointsCellOpt{}, K23:SortSymbolsCellOpt{}, K24:SortReturncodeCellOpt{}, K25:SortAssumeFailedCellOpt{}, K26:SortTraceCellOpt{}))) [functional{}()] // functional + axiom{}\implies{SortMichelsonTopCellFragment{}} (\and{SortMichelsonTopCellFragment{}} (Lbl'-LT-'michelsonTop'-GT-'-fragment{}(X0:SortParamtypeCellOpt{}, X1:SortParamvalueCellOpt{}, X2:SortStoragetypeCellOpt{}, X3:SortStoragevalueCellOpt{}, X4:SortMybalanceCellOpt{}, X5:SortMyamountCellOpt{}, X6:SortMynowCellOpt{}, X7:SortMyaddrCellOpt{}, X8:SortKnownaddrsCellOpt{}, X9:SortSourceaddrCellOpt{}, X10:SortSenderaddrCellOpt{}, X11:SortMychainidCellOpt{}, X12:SortNonceCellOpt{}, X13:SortBigmapsCellOpt{}, X14:SortScriptCellOpt{}, X15:SortKCellOpt{}, X16:SortStackCellOpt{}, X17:SortInputstackCellOpt{}, X18:SortExpectedCellOpt{}, X19:SortPreCellOpt{}, X20:SortPostCellOpt{}, X21:SortInvsCellOpt{}, X22:SortCutpointsCellOpt{}, X23:SortSymbolsCellOpt{}, X24:SortReturncodeCellOpt{}, X25:SortAssumeFailedCellOpt{}, X26:SortTraceCellOpt{}), Lbl'-LT-'michelsonTop'-GT-'-fragment{}(Y0:SortParamtypeCellOpt{}, Y1:SortParamvalueCellOpt{}, Y2:SortStoragetypeCellOpt{}, Y3:SortStoragevalueCellOpt{}, Y4:SortMybalanceCellOpt{}, Y5:SortMyamountCellOpt{}, Y6:SortMynowCellOpt{}, Y7:SortMyaddrCellOpt{}, Y8:SortKnownaddrsCellOpt{}, Y9:SortSourceaddrCellOpt{}, Y10:SortSenderaddrCellOpt{}, Y11:SortMychainidCellOpt{}, Y12:SortNonceCellOpt{}, Y13:SortBigmapsCellOpt{}, Y14:SortScriptCellOpt{}, Y15:SortKCellOpt{}, Y16:SortStackCellOpt{}, Y17:SortInputstackCellOpt{}, Y18:SortExpectedCellOpt{}, Y19:SortPreCellOpt{}, Y20:SortPostCellOpt{}, Y21:SortInvsCellOpt{}, Y22:SortCutpointsCellOpt{}, Y23:SortSymbolsCellOpt{}, Y24:SortReturncodeCellOpt{}, Y25:SortAssumeFailedCellOpt{}, Y26:SortTraceCellOpt{})), Lbl'-LT-'michelsonTop'-GT-'-fragment{}(\and{SortParamtypeCellOpt{}} (X0:SortParamtypeCellOpt{}, Y0:SortParamtypeCellOpt{}), \and{SortParamvalueCellOpt{}} (X1:SortParamvalueCellOpt{}, Y1:SortParamvalueCellOpt{}), \and{SortStoragetypeCellOpt{}} (X2:SortStoragetypeCellOpt{}, Y2:SortStoragetypeCellOpt{}), \and{SortStoragevalueCellOpt{}} (X3:SortStoragevalueCellOpt{}, Y3:SortStoragevalueCellOpt{}), \and{SortMybalanceCellOpt{}} (X4:SortMybalanceCellOpt{}, Y4:SortMybalanceCellOpt{}), \and{SortMyamountCellOpt{}} (X5:SortMyamountCellOpt{}, Y5:SortMyamountCellOpt{}), \and{SortMynowCellOpt{}} (X6:SortMynowCellOpt{}, Y6:SortMynowCellOpt{}), \and{SortMyaddrCellOpt{}} (X7:SortMyaddrCellOpt{}, Y7:SortMyaddrCellOpt{}), \and{SortKnownaddrsCellOpt{}} (X8:SortKnownaddrsCellOpt{}, Y8:SortKnownaddrsCellOpt{}), \and{SortSourceaddrCellOpt{}} (X9:SortSourceaddrCellOpt{}, Y9:SortSourceaddrCellOpt{}), \and{SortSenderaddrCellOpt{}} (X10:SortSenderaddrCellOpt{}, Y10:SortSenderaddrCellOpt{}), \and{SortMychainidCellOpt{}} (X11:SortMychainidCellOpt{}, Y11:SortMychainidCellOpt{}), \and{SortNonceCellOpt{}} (X12:SortNonceCellOpt{}, Y12:SortNonceCellOpt{}), \and{SortBigmapsCellOpt{}} (X13:SortBigmapsCellOpt{}, Y13:SortBigmapsCellOpt{}), \and{SortScriptCellOpt{}} (X14:SortScriptCellOpt{}, Y14:SortScriptCellOpt{}), \and{SortKCellOpt{}} (X15:SortKCellOpt{}, Y15:SortKCellOpt{}), \and{SortStackCellOpt{}} (X16:SortStackCellOpt{}, Y16:SortStackCellOpt{}), \and{SortInputstackCellOpt{}} (X17:SortInputstackCellOpt{}, Y17:SortInputstackCellOpt{}), \and{SortExpectedCellOpt{}} (X18:SortExpectedCellOpt{}, Y18:SortExpectedCellOpt{}), \and{SortPreCellOpt{}} (X19:SortPreCellOpt{}, Y19:SortPreCellOpt{}), \and{SortPostCellOpt{}} (X20:SortPostCellOpt{}, Y20:SortPostCellOpt{}), \and{SortInvsCellOpt{}} (X21:SortInvsCellOpt{}, Y21:SortInvsCellOpt{}), \and{SortCutpointsCellOpt{}} (X22:SortCutpointsCellOpt{}, Y22:SortCutpointsCellOpt{}), \and{SortSymbolsCellOpt{}} (X23:SortSymbolsCellOpt{}, Y23:SortSymbolsCellOpt{}), \and{SortReturncodeCellOpt{}} (X24:SortReturncodeCellOpt{}, Y24:SortReturncodeCellOpt{}), \and{SortAssumeFailedCellOpt{}} (X25:SortAssumeFailedCellOpt{}, Y25:SortAssumeFailedCellOpt{}), \and{SortTraceCellOpt{}} (X26:SortTraceCellOpt{}, Y26:SortTraceCellOpt{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortMyaddrCell{}, \equals{SortMyaddrCell{}, R} (Val:SortMyaddrCell{}, Lbl'-LT-'myaddr'-GT-'{}(K0:SortAddress{}))) [functional{}()] // functional + axiom{}\implies{SortMyaddrCell{}} (\and{SortMyaddrCell{}} (Lbl'-LT-'myaddr'-GT-'{}(X0:SortAddress{}), Lbl'-LT-'myaddr'-GT-'{}(Y0:SortAddress{})), Lbl'-LT-'myaddr'-GT-'{}(\and{SortAddress{}} (X0:SortAddress{}, Y0:SortAddress{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortMyamountCell{}, \equals{SortMyamountCell{}, R} (Val:SortMyamountCell{}, Lbl'-LT-'myamount'-GT-'{}(K0:SortMutez{}))) [functional{}()] // functional + axiom{}\implies{SortMyamountCell{}} (\and{SortMyamountCell{}} (Lbl'-LT-'myamount'-GT-'{}(X0:SortMutez{}), Lbl'-LT-'myamount'-GT-'{}(Y0:SortMutez{})), Lbl'-LT-'myamount'-GT-'{}(\and{SortMutez{}} (X0:SortMutez{}, Y0:SortMutez{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortMybalanceCell{}, \equals{SortMybalanceCell{}, R} (Val:SortMybalanceCell{}, Lbl'-LT-'mybalance'-GT-'{}(K0:SortMutez{}))) [functional{}()] // functional + axiom{}\implies{SortMybalanceCell{}} (\and{SortMybalanceCell{}} (Lbl'-LT-'mybalance'-GT-'{}(X0:SortMutez{}), Lbl'-LT-'mybalance'-GT-'{}(Y0:SortMutez{})), Lbl'-LT-'mybalance'-GT-'{}(\and{SortMutez{}} (X0:SortMutez{}, Y0:SortMutez{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortMychainidCell{}, \equals{SortMychainidCell{}, R} (Val:SortMychainidCell{}, Lbl'-LT-'mychainid'-GT-'{}(K0:SortChainId{}))) [functional{}()] // functional + axiom{}\implies{SortMychainidCell{}} (\and{SortMychainidCell{}} (Lbl'-LT-'mychainid'-GT-'{}(X0:SortChainId{}), Lbl'-LT-'mychainid'-GT-'{}(Y0:SortChainId{})), Lbl'-LT-'mychainid'-GT-'{}(\and{SortChainId{}} (X0:SortChainId{}, Y0:SortChainId{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortMynowCell{}, \equals{SortMynowCell{}, R} (Val:SortMynowCell{}, Lbl'-LT-'mynow'-GT-'{}(K0:SortTimestamp{}))) [functional{}()] // functional + axiom{}\implies{SortMynowCell{}} (\and{SortMynowCell{}} (Lbl'-LT-'mynow'-GT-'{}(X0:SortTimestamp{}), Lbl'-LT-'mynow'-GT-'{}(Y0:SortTimestamp{})), Lbl'-LT-'mynow'-GT-'{}(\and{SortTimestamp{}} (X0:SortTimestamp{}, Y0:SortTimestamp{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortNonceCell{}, \equals{SortNonceCell{}, R} (Val:SortNonceCell{}, Lbl'-LT-'nonce'-GT-'{}(K0:SortOperationNonce{}))) [functional{}()] // functional + axiom{}\implies{SortNonceCell{}} (\and{SortNonceCell{}} (Lbl'-LT-'nonce'-GT-'{}(X0:SortOperationNonce{}), Lbl'-LT-'nonce'-GT-'{}(Y0:SortOperationNonce{})), Lbl'-LT-'nonce'-GT-'{}(\and{SortOperationNonce{}} (X0:SortOperationNonce{}, Y0:SortOperationNonce{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortParamtypeCell{}, \equals{SortParamtypeCell{}, R} (Val:SortParamtypeCell{}, Lbl'-LT-'paramtype'-GT-'{}(K0:SortPreType{}))) [functional{}()] // functional + axiom{}\implies{SortParamtypeCell{}} (\and{SortParamtypeCell{}} (Lbl'-LT-'paramtype'-GT-'{}(X0:SortPreType{}), Lbl'-LT-'paramtype'-GT-'{}(Y0:SortPreType{})), Lbl'-LT-'paramtype'-GT-'{}(\and{SortPreType{}} (X0:SortPreType{}, Y0:SortPreType{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortParamvalueCell{}, \equals{SortParamvalueCell{}, R} (Val:SortParamvalueCell{}, Lbl'-LT-'paramvalue'-GT-'{}(K0:SortPreData{}))) [functional{}()] // functional + axiom{}\implies{SortParamvalueCell{}} (\and{SortParamvalueCell{}} (Lbl'-LT-'paramvalue'-GT-'{}(X0:SortPreData{}), Lbl'-LT-'paramvalue'-GT-'{}(Y0:SortPreData{})), Lbl'-LT-'paramvalue'-GT-'{}(\and{SortPreData{}} (X0:SortPreData{}, Y0:SortPreData{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortPostCell{}, \equals{SortPostCell{}, R} (Val:SortPostCell{}, Lbl'-LT-'post'-GT-'{}(K0:SortBlockList{}))) [functional{}()] // functional + axiom{}\implies{SortPostCell{}} (\and{SortPostCell{}} (Lbl'-LT-'post'-GT-'{}(X0:SortBlockList{}), Lbl'-LT-'post'-GT-'{}(Y0:SortBlockList{})), Lbl'-LT-'post'-GT-'{}(\and{SortBlockList{}} (X0:SortBlockList{}, Y0:SortBlockList{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortPreCell{}, \equals{SortPreCell{}, R} (Val:SortPreCell{}, Lbl'-LT-'pre'-GT-'{}(K0:SortBlockList{}))) [functional{}()] // functional + axiom{}\implies{SortPreCell{}} (\and{SortPreCell{}} (Lbl'-LT-'pre'-GT-'{}(X0:SortBlockList{}), Lbl'-LT-'pre'-GT-'{}(Y0:SortBlockList{})), Lbl'-LT-'pre'-GT-'{}(\and{SortBlockList{}} (X0:SortBlockList{}, Y0:SortBlockList{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortReturncodeCell{}, \equals{SortReturncodeCell{}, R} (Val:SortReturncodeCell{}, Lbl'-LT-'returncode'-GT-'{}(K0:SortInt{}))) [functional{}()] // functional + axiom{}\implies{SortReturncodeCell{}} (\and{SortReturncodeCell{}} (Lbl'-LT-'returncode'-GT-'{}(X0:SortInt{}), Lbl'-LT-'returncode'-GT-'{}(Y0:SortInt{})), Lbl'-LT-'returncode'-GT-'{}(\and{SortInt{}} (X0:SortInt{}, Y0:SortInt{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortScriptCell{}, \equals{SortScriptCell{}, R} (Val:SortScriptCell{}, Lbl'-LT-'script'-GT-'{}(K0:SortPreData{}))) [functional{}()] // functional + axiom{}\implies{SortScriptCell{}} (\and{SortScriptCell{}} (Lbl'-LT-'script'-GT-'{}(X0:SortPreData{}), Lbl'-LT-'script'-GT-'{}(Y0:SortPreData{})), Lbl'-LT-'script'-GT-'{}(\and{SortPreData{}} (X0:SortPreData{}, Y0:SortPreData{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortSenderaddrCell{}, \equals{SortSenderaddrCell{}, R} (Val:SortSenderaddrCell{}, Lbl'-LT-'senderaddr'-GT-'{}(K0:SortAddress{}))) [functional{}()] // functional + axiom{}\implies{SortSenderaddrCell{}} (\and{SortSenderaddrCell{}} (Lbl'-LT-'senderaddr'-GT-'{}(X0:SortAddress{}), Lbl'-LT-'senderaddr'-GT-'{}(Y0:SortAddress{})), Lbl'-LT-'senderaddr'-GT-'{}(\and{SortAddress{}} (X0:SortAddress{}, Y0:SortAddress{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortSourceaddrCell{}, \equals{SortSourceaddrCell{}, R} (Val:SortSourceaddrCell{}, Lbl'-LT-'sourceaddr'-GT-'{}(K0:SortAddress{}))) [functional{}()] // functional + axiom{}\implies{SortSourceaddrCell{}} (\and{SortSourceaddrCell{}} (Lbl'-LT-'sourceaddr'-GT-'{}(X0:SortAddress{}), Lbl'-LT-'sourceaddr'-GT-'{}(Y0:SortAddress{})), Lbl'-LT-'sourceaddr'-GT-'{}(\and{SortAddress{}} (X0:SortAddress{}, Y0:SortAddress{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortStackCell{}, \equals{SortStackCell{}, R} (Val:SortStackCell{}, Lbl'-LT-'stack'-GT-'{}(K0:SortInternalStack{}))) [functional{}()] // functional + axiom{}\implies{SortStackCell{}} (\and{SortStackCell{}} (Lbl'-LT-'stack'-GT-'{}(X0:SortInternalStack{}), Lbl'-LT-'stack'-GT-'{}(Y0:SortInternalStack{})), Lbl'-LT-'stack'-GT-'{}(\and{SortInternalStack{}} (X0:SortInternalStack{}, Y0:SortInternalStack{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortStoragetypeCell{}, \equals{SortStoragetypeCell{}, R} (Val:SortStoragetypeCell{}, Lbl'-LT-'storagetype'-GT-'{}(K0:SortPreType{}))) [functional{}()] // functional + axiom{}\implies{SortStoragetypeCell{}} (\and{SortStoragetypeCell{}} (Lbl'-LT-'storagetype'-GT-'{}(X0:SortPreType{}), Lbl'-LT-'storagetype'-GT-'{}(Y0:SortPreType{})), Lbl'-LT-'storagetype'-GT-'{}(\and{SortPreType{}} (X0:SortPreType{}, Y0:SortPreType{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortStoragevalueCell{}, \equals{SortStoragevalueCell{}, R} (Val:SortStoragevalueCell{}, Lbl'-LT-'storagevalue'-GT-'{}(K0:SortPreData{}))) [functional{}()] // functional + axiom{}\implies{SortStoragevalueCell{}} (\and{SortStoragevalueCell{}} (Lbl'-LT-'storagevalue'-GT-'{}(X0:SortPreData{}), Lbl'-LT-'storagevalue'-GT-'{}(Y0:SortPreData{})), Lbl'-LT-'storagevalue'-GT-'{}(\and{SortPreData{}} (X0:SortPreData{}, Y0:SortPreData{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortSymbolsCell{}, \equals{SortSymbolsCell{}, R} (Val:SortSymbolsCell{}, Lbl'-LT-'symbols'-GT-'{}(K0:SortMap{}))) [functional{}()] // functional + axiom{}\implies{SortSymbolsCell{}} (\and{SortSymbolsCell{}} (Lbl'-LT-'symbols'-GT-'{}(X0:SortMap{}), Lbl'-LT-'symbols'-GT-'{}(Y0:SortMap{})), Lbl'-LT-'symbols'-GT-'{}(\and{SortMap{}} (X0:SortMap{}, Y0:SortMap{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortTraceCell{}, \equals{SortTraceCell{}, R} (Val:SortTraceCell{}, Lbl'-LT-'trace'-GT-'{}(K0:SortK{}))) [functional{}()] // functional + axiom{}\implies{SortTraceCell{}} (\and{SortTraceCell{}} (Lbl'-LT-'trace'-GT-'{}(X0:SortK{}), Lbl'-LT-'trace'-GT-'{}(Y0:SortK{})), Lbl'-LT-'trace'-GT-'{}(\and{SortK{}} (X0:SortK{}, Y0:SortK{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(Y0:SortOutputStack{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(Y0:SortOutputStack{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(Y0:SortOutputStack{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(Y0:SortOutputStack{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(Y0:SortOutputStack{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(Y0:SortOutputStack{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(K0:SortBlockList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{})), LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(\and{SortBlockList{}} (X0:SortBlockList{}, Y0:SortBlockList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(Y0:SortOutputStack{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(K0:SortBlockList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(Y0:SortBlockList{})), LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(\and{SortBlockList{}} (X0:SortBlockList{}, Y0:SortBlockList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(Y0:SortOutputStack{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortError{}, \equals{SortError{}, R} (Val:SortError{}, LblAborted'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Error'Unds'String'Unds'KItem'Unds'K'Unds'K{}(K0:SortString{}, K1:SortKItem{}, K2:SortK{}, K3:SortK{}))) [functional{}()] // functional + axiom{}\implies{SortError{}} (\and{SortError{}} (LblAborted'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Error'Unds'String'Unds'KItem'Unds'K'Unds'K{}(X0:SortString{}, X1:SortKItem{}, X2:SortK{}, X3:SortK{}), LblAborted'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Error'Unds'String'Unds'KItem'Unds'K'Unds'K{}(Y0:SortString{}, Y1:SortKItem{}, Y2:SortK{}, Y3:SortK{})), LblAborted'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Error'Unds'String'Unds'KItem'Unds'K'Unds'K{}(\and{SortString{}} (X0:SortString{}, Y0:SortString{}), \and{SortKItem{}} (X1:SortKItem{}, Y1:SortKItem{}), \and{SortK{}} (X2:SortK{}, Y2:SortK{}), \and{SortK{}} (X3:SortK{}, Y3:SortK{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(Y0:SortOutputStack{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(K0:SortOutputStack{}, K1:SortBlock{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(Y0:SortOutputStack{}, Y1:SortBlock{})), LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(\and{SortOutputStack{}} (X0:SortOutputStack{}, Y0:SortOutputStack{}), \and{SortBlock{}} (X1:SortBlock{}, Y1:SortBlock{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortBigMapEntry{}, \equals{SortBigMapEntry{}, R} (Val:SortBigMapEntry{}, LblBig'Unds'map'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntry'Unds'Int'Unds'Type'Unds'Type'Unds'EmptyBlock{}(K0:SortInt{}, K1:SortType{}, K2:SortType{}, K3:SortEmptyBlock{}))) [functional{}()] // functional + axiom{}\implies{SortBigMapEntry{}} (\and{SortBigMapEntry{}} (LblBig'Unds'map'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntry'Unds'Int'Unds'Type'Unds'Type'Unds'EmptyBlock{}(X0:SortInt{}, X1:SortType{}, X2:SortType{}, X3:SortEmptyBlock{}), LblBig'Unds'map'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntry'Unds'Int'Unds'Type'Unds'Type'Unds'EmptyBlock{}(Y0:SortInt{}, Y1:SortType{}, Y2:SortType{}, Y3:SortEmptyBlock{})), LblBig'Unds'map'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntry'Unds'Int'Unds'Type'Unds'Type'Unds'EmptyBlock{}(\and{SortInt{}} (X0:SortInt{}, Y0:SortInt{}), \and{SortType{}} (X1:SortType{}, Y1:SortType{}), \and{SortType{}} (X2:SortType{}, Y2:SortType{}), \and{SortEmptyBlock{}} (X3:SortEmptyBlock{}, Y3:SortEmptyBlock{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortBigMapEntry{}} (\and{SortBigMapEntry{}} (LblBig'Unds'map'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntry'Unds'Int'Unds'Type'Unds'Type'Unds'EmptyBlock{}(X0:SortInt{}, X1:SortType{}, X2:SortType{}, X3:SortEmptyBlock{}), LblBig'Unds'map'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntry'Unds'Int'Unds'Type'Unds'Type'Unds'MapLiteral{}(Y0:SortInt{}, Y1:SortType{}, Y2:SortType{}, Y3:SortMapLiteral{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortBigMapEntry{}, \equals{SortBigMapEntry{}, R} (Val:SortBigMapEntry{}, LblBig'Unds'map'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntry'Unds'Int'Unds'Type'Unds'Type'Unds'MapLiteral{}(K0:SortInt{}, K1:SortType{}, K2:SortType{}, K3:SortMapLiteral{}))) [functional{}()] // functional + axiom{}\implies{SortBigMapEntry{}} (\and{SortBigMapEntry{}} (LblBig'Unds'map'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntry'Unds'Int'Unds'Type'Unds'Type'Unds'MapLiteral{}(X0:SortInt{}, X1:SortType{}, X2:SortType{}, X3:SortMapLiteral{}), LblBig'Unds'map'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntry'Unds'Int'Unds'Type'Unds'Type'Unds'MapLiteral{}(Y0:SortInt{}, Y1:SortType{}, Y2:SortType{}, Y3:SortMapLiteral{})), LblBig'Unds'map'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntry'Unds'Int'Unds'Type'Unds'Type'Unds'MapLiteral{}(\and{SortInt{}} (X0:SortInt{}, Y0:SortInt{}), \and{SortType{}} (X1:SortType{}, Y1:SortType{}), \and{SortType{}} (X2:SortType{}, Y2:SortType{}), \and{SortMapLiteral{}} (X3:SortMapLiteral{}, Y3:SortMapLiteral{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortNumTypeName{}, \equals{SortNumTypeName{}, R} (Val:SortNumTypeName{}, LblBinOpNumType'LParUndsCommUndsRParUnds'MICHELSON'Unds'NumTypeName'Unds'NumTypeName'Unds'NumTypeName{}(K0:SortNumTypeName{}, K1:SortNumTypeName{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInt{}, \equals{SortInt{}, R} (Val:SortInt{}, LblBytes2Int'LParUndsCommUndsCommUndsRParUnds'BYTES-HOOKED'Unds'Int'Unds'Bytes'Unds'Endianness'Unds'Signedness{}(K0:SortBytes{}, K1:SortEndianness{}, K2:SortSignedness{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortString{}, \equals{SortString{}, R} (Val:SortString{}, LblBytes2String'LParUndsRParUnds'BYTES-HOOKED'Unds'String'Unds'Bytes{}(K0:SortBytes{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(K0:SortAnnotationList{}, K1:SortType{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{})), LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}), \and{SortType{}} (X1:SortType{}, Y1:SortType{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(K0:SortAnnotationList{}, K1:SortContract{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(Y0:SortAnnotationList{}, Y1:SortContract{})), LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}), \and{SortContract{}} (X1:SortContract{}, Y1:SortContract{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(K0:SortInt{}, K1:SortInvariant{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(Y0:SortInt{}, Y1:SortInvariant{})), LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(\and{SortInt{}} (X0:SortInt{}, Y0:SortInt{}), \and{SortInvariant{}} (X1:SortInvariant{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortBlockchainOperation{}, \equals{SortBlockchainOperation{}, R} (Val:SortBlockchainOperation{}, LblCreate'Unds'contract'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Contract'Unds'OptionData'Unds'Mutez'Unds'Data{}(K0:SortInt{}, K1:SortContract{}, K2:SortOptionData{}, K3:SortMutez{}, K4:SortData{}))) [functional{}()] // functional + axiom{}\implies{SortBlockchainOperation{}} (\and{SortBlockchainOperation{}} (LblCreate'Unds'contract'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Contract'Unds'OptionData'Unds'Mutez'Unds'Data{}(X0:SortInt{}, X1:SortContract{}, X2:SortOptionData{}, X3:SortMutez{}, X4:SortData{}), LblCreate'Unds'contract'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Contract'Unds'OptionData'Unds'Mutez'Unds'Data{}(Y0:SortInt{}, Y1:SortContract{}, Y2:SortOptionData{}, Y3:SortMutez{}, Y4:SortData{})), LblCreate'Unds'contract'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Contract'Unds'OptionData'Unds'Mutez'Unds'Data{}(\and{SortInt{}} (X0:SortInt{}, Y0:SortInt{}), \and{SortContract{}} (X1:SortContract{}, Y1:SortContract{}), \and{SortOptionData{}} (X2:SortOptionData{}, Y2:SortOptionData{}), \and{SortMutez{}} (X3:SortMutez{}, Y3:SortMutez{}), \and{SortData{}} (X4:SortData{}, Y4:SortData{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortBlockchainOperation{}} (\and{SortBlockchainOperation{}} (LblCreate'Unds'contract'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Contract'Unds'OptionData'Unds'Mutez'Unds'Data{}(X0:SortInt{}, X1:SortContract{}, X2:SortOptionData{}, X3:SortMutez{}, X4:SortData{}), LblSet'Unds'delegate'LParUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'OptionData{}(Y0:SortInt{}, Y1:SortOptionData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortBlockchainOperation{}} (\and{SortBlockchainOperation{}} (LblCreate'Unds'contract'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Contract'Unds'OptionData'Unds'Mutez'Unds'Data{}(X0:SortInt{}, X1:SortContract{}, X2:SortOptionData{}, X3:SortMutez{}, X4:SortData{}), LblTransfer'Unds'tokens'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Data'Unds'Mutez'Unds'Address{}(Y0:SortInt{}, Y1:SortData{}, Y2:SortMutez{}, Y3:SortAddress{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(K0:SortInt{}, K1:SortStack{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(Y0:SortInt{}, Y1:SortStack{})), LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(\and{SortInt{}} (X0:SortInt{}, Y0:SortInt{}), \and{SortStack{}} (X1:SortStack{}, Y1:SortStack{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(K0:SortStack{}, K1:SortStackElement{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(Y0:SortStack{}, Y1:SortStackElement{})), LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(\and{SortStack{}} (X0:SortStack{}, Y0:SortStack{}), \and{SortStackElement{}} (X1:SortStackElement{}, Y1:SortStackElement{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(K0:SortAnnotationList{}, K1:SortInt{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{})), LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}), \and{SortInt{}} (X1:SortInt{}, Y1:SortInt{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(K0:SortAnnotationList{}, K1:SortBlock{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{})), LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}), \and{SortBlock{}} (X1:SortBlock{}, Y1:SortBlock{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(K0:SortAnnotationList{}, K1:SortInt{}, K2:SortBlock{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortInt{}, Y2:SortBlock{})), LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}), \and{SortInt{}} (X1:SortInt{}, Y1:SortInt{}), \and{SortBlock{}} (X2:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(K0:SortAnnotationList{}, K1:SortInt{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{})), LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}), \and{SortInt{}} (X1:SortInt{}, Y1:SortInt{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(K0:SortInt{}, K1:SortStack{}, K2:SortStackElement{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(Y0:SortInt{}, Y1:SortStack{}, Y2:SortStackElement{})), LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(\and{SortInt{}} (X0:SortInt{}, Y0:SortInt{}), \and{SortStack{}} (X1:SortStack{}, Y1:SortStack{}), \and{SortStackElement{}} (X2:SortStackElement{}, Y2:SortStackElement{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(K0:SortK{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(Y0:SortK{})), LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(\and{SortK{}} (X0:SortK{}, Y0:SortK{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(K0:SortAnnotationList{}, K1:SortInt{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(Y0:SortAnnotationList{}, Y1:SortInt{})), LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}), \and{SortInt{}} (X1:SortInt{}, Y1:SortInt{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(K0:SortAnnotationList{}, K1:SortType{}, K2:SortType{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{})), LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}), \and{SortType{}} (X1:SortType{}, Y1:SortType{}), \and{SortType{}} (X2:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(K0:SortAnnotationList{}, K1:SortType{}, K2:SortType{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{})), LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}), \and{SortType{}} (X1:SortType{}, Y1:SortType{}), \and{SortType{}} (X2:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(K0:SortAnnotationList{}, K1:SortType{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{})), LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}), \and{SortType{}} (X1:SortType{}, Y1:SortType{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortMapEntry{}, \equals{SortMapEntry{}, R} (Val:SortMapEntry{}, LblElt'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'MapEntry'Unds'Data'Unds'Data{}(K0:SortData{}, K1:SortData{}))) [functional{}()] // functional + axiom{}\implies{SortMapEntry{}} (\and{SortMapEntry{}} (LblElt'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'MapEntry'Unds'Data'Unds'Data{}(X0:SortData{}, X1:SortData{}), LblElt'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'MapEntry'Unds'Data'Unds'Data{}(Y0:SortData{}, Y1:SortData{})), LblElt'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'MapEntry'Unds'Data'Unds'Data{}(\and{SortData{}} (X0:SortData{}, Y0:SortData{}), \and{SortData{}} (X1:SortData{}, Y1:SortData{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortOtherContractsMapEntry{}, \equals{SortOtherContractsMapEntry{}, R} (Val:SortOtherContractsMapEntry{}, LblElt'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OtherContractsMapEntry'Unds'String'Unds'Type{}(K0:SortString{}, K1:SortType{}))) [functional{}()] // functional + axiom{}\implies{SortOtherContractsMapEntry{}} (\and{SortOtherContractsMapEntry{}} (LblElt'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OtherContractsMapEntry'Unds'String'Unds'Type{}(X0:SortString{}, X1:SortType{}), LblElt'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OtherContractsMapEntry'Unds'String'Unds'Type{}(Y0:SortString{}, Y1:SortType{})), LblElt'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OtherContractsMapEntry'Unds'String'Unds'Type{}(\and{SortString{}} (X0:SortString{}, Y0:SortString{}), \and{SortType{}} (X1:SortType{}, Y1:SortType{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortString{}, \equals{SortString{}, R} (Val:SortString{}, LblFloat2String'LParUndsRParUnds'STRING-COMMON'Unds'String'Unds'Float{}(K0:SortFloat{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(K0:SortAnnotationList{}, K1:SortBlock{}, K2:SortBlock{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{})), LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}), \and{SortBlock{}} (X1:SortBlock{}, Y1:SortBlock{}), \and{SortBlock{}} (X2:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(K0:SortAnnotationList{}, K1:SortBlock{}, K2:SortBlock{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{})), LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}), \and{SortBlock{}} (X1:SortBlock{}, Y1:SortBlock{}), \and{SortBlock{}} (X2:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(K0:SortAnnotationList{}, K1:SortBlock{}, K2:SortBlock{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{})), LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}), \and{SortBlock{}} (X1:SortBlock{}, Y1:SortBlock{}), \and{SortBlock{}} (X2:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(K0:SortAnnotationList{}, K1:SortBlock{}, K2:SortBlock{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}, Y2:SortBlock{})), LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}), \and{SortBlock{}} (X1:SortBlock{}, Y1:SortBlock{}), \and{SortBlock{}} (X2:SortBlock{}, Y2:SortBlock{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(K0:SortAnnotationList{}, K1:SortBlock{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{})), LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}), \and{SortBlock{}} (X1:SortBlock{}, Y1:SortBlock{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortString{}, \equals{SortString{}, R} (Val:SortString{}, LblId2String'LParUndsRParUnds'ID-COMMON'Unds'String'Unds'Id{}(K0:SortId{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBytes{}, \equals{SortBytes{}, R} (Val:SortBytes{}, LblInt2Bytes'LParUndsCommUndsCommUndsRParUnds'BYTES-HOOKED'Unds'Bytes'Unds'Int'Unds'Endianness'Unds'Signedness{}(K0:SortInt{}, K1:SortEndianness{}, K2:SortSignedness{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBytes{}, \equals{SortBytes{}, R} (Val:SortBytes{}, LblInt2Bytes'LParUndsCommUndsCommUndsRParUnds'BYTES-HOOKED'Unds'Bytes'Unds'Int'Unds'Int'Unds'Endianness{}(K0:SortInt{}, K1:SortInt{}, K2:SortEndianness{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortString{}, \equals{SortString{}, R} (Val:SortString{}, LblInt2String'LParUndsRParUnds'STRING-COMMON'Unds'String'Unds'Int{}(K0:SortInt{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(K0:SortAnnotationList{}, K1:SortType{}, K2:SortType{}, K3:SortBlock{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortType{}, Y3:SortBlock{})), LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}), \and{SortType{}} (X1:SortType{}, Y1:SortType{}), \and{SortType{}} (X2:SortType{}, Y2:SortType{}), \and{SortBlock{}} (X3:SortBlock{}, Y3:SortBlock{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(K0:SortAnnotationList{}, K1:SortType{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{})), LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}), \and{SortType{}} (X1:SortType{}, Y1:SortType{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(K0:SortAnnotationList{}, K1:SortBlock{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{})), LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}), \and{SortBlock{}} (X1:SortBlock{}, Y1:SortBlock{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(K0:SortAnnotationList{}, K1:SortBlock{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{})), LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}), \and{SortBlock{}} (X1:SortBlock{}, Y1:SortBlock{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortOrData{}, \equals{SortOrData{}, R} (Val:SortOrData{}, LblLeft'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(K0:SortData{}))) [functional{}()] // functional + axiom{}\implies{SortOrData{}} (\and{SortOrData{}} (LblLeft'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(X0:SortData{}), LblLeft'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(Y0:SortData{})), LblLeft'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(\and{SortData{}} (X0:SortData{}, Y0:SortData{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortOrData{}} (\and{SortOrData{}} (LblLeft'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(X0:SortData{}), LblRight'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(Y0:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortSet{}, \equals{SortSet{}, R} (Val:SortSet{}, LblList2Set'LParUndsRParUnds'COLLECTIONS'Unds'Set'Unds'List{}(K0:SortList{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortList{}, \equals{SortList{}, R} (Val:SortList{}, LblListItem{}(K0:SortKItem{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(K0:SortAnnotationList{}, K1:SortBlock{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(Y0:SortAnnotationList{}, Y1:SortBlock{})), LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}), \and{SortBlock{}} (X1:SortBlock{}, Y1:SortBlock{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortMap{}, \equals{SortMap{}, R} (Val:SortMap{}, LblMap'Coln'update{}(K0:SortMap{}, K1:SortKItem{}, K2:SortKItem{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(K0:SortAnnotationList{}, K1:SortType{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{})), LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}), \and{SortType{}} (X1:SortType{}, Y1:SortType{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(K0:SortAnnotationList{}, K1:SortType{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{})), LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}), \and{SortType{}} (X1:SortType{}, Y1:SortType{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortMaybeTypeName{}, \equals{SortMaybeTypeName{}, R} (Val:SortMaybeTypeName{}, LblNoneType'Unds'MICHELSON'Unds'MaybeTypeName{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortOptionData{}, \equals{SortOptionData{}, R} (Val:SortOptionData{}, LblNone'Unds'MICHELSON-COMMON-SYNTAX'Unds'OptionData{}())) [functional{}()] // functional + axiom{}\not{SortOptionData{}} (\and{SortOptionData{}} (LblNone'Unds'MICHELSON-COMMON-SYNTAX'Unds'OptionData{}(), LblSome'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OptionData'Unds'Data{}(Y0:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(K0:SortString{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{})), LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(\and{SortString{}} (X0:SortString{}, Y0:SortString{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [functional{}()] // functional + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(K0:SortAnnotationList{}, K1:SortType{}, K2:SortData{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortData{}), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Y0:SortAnnotationList{}, Y1:SortType{}, Y2:SortData{})), LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}), \and{SortType{}} (X1:SortType{}, Y1:SortType{}), \and{SortData{}} (X2:SortData{}, Y2:SortData{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortData{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortData{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortData{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortData{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortData{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortData{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortData{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortData{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortData{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortData{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortData{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortData{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortData{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortData{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortData{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortData{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortData{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortData{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortData{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortData{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortData{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortData{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortPair{}, \equals{SortPair{}, R} (Val:SortPair{}, LblPair'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Pair'Unds'Data'Unds'Data{}(K0:SortData{}, K1:SortData{}))) [functional{}()] // functional + axiom{}\implies{SortPair{}} (\and{SortPair{}} (LblPair'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Pair'Unds'Data'Unds'Data{}(X0:SortData{}, X1:SortData{}), LblPair'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Pair'Unds'Data'Unds'Data{}(Y0:SortData{}, Y1:SortData{})), LblPair'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Pair'Unds'Data'Unds'Data{}(\and{SortData{}} (X0:SortData{}, Y0:SortData{}), \and{SortData{}} (X1:SortData{}, Y1:SortData{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(K0:SortAnnotationList{}, K1:SortType{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{})), LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}), \and{SortType{}} (X1:SortType{}, Y1:SortType{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortOrData{}, \equals{SortOrData{}, R} (Val:SortOrData{}, LblRight'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(K0:SortData{}))) [functional{}()] // functional + axiom{}\implies{SortOrData{}} (\and{SortOrData{}} (LblRight'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(X0:SortData{}), LblRight'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(Y0:SortData{})), LblRight'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(\and{SortData{}} (X0:SortData{}, Y0:SortData{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}())) [functional{}()] // functional + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortList{}, \equals{SortList{}, R} (Val:SortList{}, LblSet2List'LParUndsRParUnds'COLLECTIONS'Unds'List'Unds'Set{}(K0:SortSet{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortSet{}, \equals{SortSet{}, R} (Val:SortSet{}, LblSet'Coln'difference{}(K0:SortSet{}, K1:SortSet{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, LblSet'Coln'in{}(K0:SortKItem{}, K1:SortSet{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortSet{}, \equals{SortSet{}, R} (Val:SortSet{}, LblSetItem{}(K0:SortKItem{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBlockchainOperation{}, \equals{SortBlockchainOperation{}, R} (Val:SortBlockchainOperation{}, LblSet'Unds'delegate'LParUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'OptionData{}(K0:SortInt{}, K1:SortOptionData{}))) [functional{}()] // functional + axiom{}\implies{SortBlockchainOperation{}} (\and{SortBlockchainOperation{}} (LblSet'Unds'delegate'LParUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'OptionData{}(X0:SortInt{}, X1:SortOptionData{}), LblSet'Unds'delegate'LParUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'OptionData{}(Y0:SortInt{}, Y1:SortOptionData{})), LblSet'Unds'delegate'LParUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'OptionData{}(\and{SortInt{}} (X0:SortInt{}, Y0:SortInt{}), \and{SortOptionData{}} (X1:SortOptionData{}, Y1:SortOptionData{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortBlockchainOperation{}} (\and{SortBlockchainOperation{}} (LblSet'Unds'delegate'LParUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'OptionData{}(X0:SortInt{}, X1:SortOptionData{}), LblTransfer'Unds'tokens'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Data'Unds'Mutez'Unds'Address{}(Y0:SortInt{}, Y1:SortData{}, Y2:SortMutez{}, Y3:SortAddress{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortOptionData{}, \equals{SortOptionData{}, R} (Val:SortOptionData{}, LblSome'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OptionData'Unds'Data{}(K0:SortData{}))) [functional{}()] // functional + axiom{}\implies{SortOptionData{}} (\and{SortOptionData{}} (LblSome'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OptionData'Unds'Data{}(X0:SortData{}), LblSome'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OptionData'Unds'Data{}(Y0:SortData{})), LblSome'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OptionData'Unds'Data{}(\and{SortData{}} (X0:SortData{}, Y0:SortData{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortStackElementLiteral{}, \equals{SortStackElementLiteral{}, R} (Val:SortStackElementLiteral{}, LblStack'Unds'elt'UndsUndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'StackElementLiteral'Unds'Type'Unds'Data{}(K0:SortType{}, K1:SortData{}))) [functional{}()] // functional + axiom{}\implies{SortStackElementLiteral{}} (\and{SortStackElementLiteral{}} (LblStack'Unds'elt'UndsUndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'StackElementLiteral'Unds'Type'Unds'Data{}(X0:SortType{}, X1:SortData{}), LblStack'Unds'elt'UndsUndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'StackElementLiteral'Unds'Type'Unds'Data{}(Y0:SortType{}, Y1:SortData{})), LblStack'Unds'elt'UndsUndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'StackElementLiteral'Unds'Type'Unds'Data{}(\and{SortType{}} (X0:SortType{}, Y0:SortType{}), \and{SortData{}} (X1:SortData{}, Y1:SortData{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortBytes{}, \equals{SortBytes{}, R} (Val:SortBytes{}, LblString2Bytes'LParUndsRParUnds'BYTES-HOOKED'Unds'Bytes'Unds'String{}(K0:SortString{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortId{}, \equals{SortId{}, R} (Val:SortId{}, LblString2Id'LParUndsRParUnds'ID-COMMON'Unds'Id'Unds'String{}(K0:SortString{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(K0:SortString{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(Y0:SortString{})), LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(\and{SortString{}} (X0:SortString{}, Y0:SortString{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortBlockchainOperation{}, \equals{SortBlockchainOperation{}, R} (Val:SortBlockchainOperation{}, LblTransfer'Unds'tokens'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Data'Unds'Mutez'Unds'Address{}(K0:SortInt{}, K1:SortData{}, K2:SortMutez{}, K3:SortAddress{}))) [functional{}()] // functional + axiom{}\implies{SortBlockchainOperation{}} (\and{SortBlockchainOperation{}} (LblTransfer'Unds'tokens'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Data'Unds'Mutez'Unds'Address{}(X0:SortInt{}, X1:SortData{}, X2:SortMutez{}, X3:SortAddress{}), LblTransfer'Unds'tokens'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Data'Unds'Mutez'Unds'Address{}(Y0:SortInt{}, Y1:SortData{}, Y2:SortMutez{}, Y3:SortAddress{})), LblTransfer'Unds'tokens'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Data'Unds'Mutez'Unds'Address{}(\and{SortInt{}} (X0:SortInt{}, Y0:SortInt{}), \and{SortData{}} (X1:SortData{}, Y1:SortData{}), \and{SortMutez{}} (X2:SortMutez{}, Y2:SortMutez{}), \and{SortAddress{}} (X3:SortAddress{}, Y3:SortAddress{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(K0:SortAnnotationList{}, K1:SortType{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(Y0:SortAnnotationList{}, Y1:SortType{})), LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}), \and{SortType{}} (X1:SortType{}, Y1:SortType{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortInstruction{}} (\and{SortInstruction{}} (LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortSimpleData{}, \equals{SortSimpleData{}, R} (Val:SortSimpleData{}, LblUnit'Unds'MICHELSON-COMMON-SYNTAX'Unds'SimpleData{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInstruction{}, \equals{SortInstruction{}, R} (Val:SortInstruction{}, LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(K0:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortInstruction{}} (\and{SortInstruction{}} (LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{}), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(Y0:SortAnnotationList{})), LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(\and{SortAnnotationList{}} (X0:SortAnnotationList{}, Y0:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortStackElement{}, \equals{SortStackElement{}, R} (Val:SortStackElement{}, Lbl'LSqBUndsUndsRSqBUnds'MICHELSON-COMMON'Unds'StackElement'Unds'TypeName'Unds'Data{}(K0:SortTypeName{}, K1:SortData{}))) [functional{}()] // functional + axiom{}\implies{SortStackElement{}} (\and{SortStackElement{}} (Lbl'LSqBUndsUndsRSqBUnds'MICHELSON-COMMON'Unds'StackElement'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}), Lbl'LSqBUndsUndsRSqBUnds'MICHELSON-COMMON'Unds'StackElement'Unds'TypeName'Unds'Data{}(Y0:SortTypeName{}, Y1:SortData{})), Lbl'LSqBUndsUndsRSqBUnds'MICHELSON-COMMON'Unds'StackElement'Unds'TypeName'Unds'Data{}(\and{SortTypeName{}} (X0:SortTypeName{}, Y0:SortTypeName{}), \and{SortData{}} (X1:SortData{}, Y1:SortData{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortInt{}, \equals{SortInt{}, R} (Val:SortInt{}, Lbl'UndsAnd-'Int'Unds'{}(K0:SortInt{}, K1:SortInt{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInt{}, \equals{SortInt{}, R} (Val:SortInt{}, Lbl'UndsStar'Int'Unds'{}(K0:SortInt{}, K1:SortInt{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBytes{}, \equals{SortBytes{}, R} (Val:SortBytes{}, Lbl'UndsPlus'Bytes'UndsUnds'BYTES-HOOKED'Unds'Bytes'Unds'Bytes'Unds'Bytes{}(K0:SortBytes{}, K1:SortBytes{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInt{}, \equals{SortInt{}, R} (Val:SortInt{}, Lbl'UndsPlus'Int'Unds'{}(K0:SortInt{}, K1:SortInt{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortString{}, \equals{SortString{}, R} (Val:SortString{}, Lbl'UndsPlus'String'UndsUnds'STRING-COMMON'Unds'String'Unds'String'Unds'String{}(K0:SortString{}, K1:SortString{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInt{}, \equals{SortInt{}, R} (Val:SortInt{}, Lbl'Unds'-Int'Unds'{}(K0:SortInt{}, K1:SortInt{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortMap{}, \equals{SortMap{}, R} (Val:SortMap{}, Lbl'Unds'-Map'UndsUnds'MAP'Unds'Map'Unds'Map'Unds'Map{}(K0:SortMap{}, K1:SortMap{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortContract{}, \equals{SortContract{}, R} (Val:SortContract{}, Lbl'UndsSClnUndsSClnUndsSClnUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'CodeDecl'Unds'ParameterDecl'Unds'StorageDecl{}(K0:SortCodeDecl{}, K1:SortParameterDecl{}, K2:SortStorageDecl{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortContract{}, \equals{SortContract{}, R} (Val:SortContract{}, Lbl'UndsSClnUndsSClnUndsSClnUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'CodeDecl'Unds'StorageDecl'Unds'ParameterDecl{}(K0:SortCodeDecl{}, K1:SortStorageDecl{}, K2:SortParameterDecl{}))) [functional{}()] // functional + axiom{}\implies{SortContract{}} (\and{SortContract{}} (Lbl'UndsSClnUndsSClnUndsSClnUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'CodeDecl'Unds'StorageDecl'Unds'ParameterDecl{}(X0:SortCodeDecl{}, X1:SortStorageDecl{}, X2:SortParameterDecl{}), Lbl'UndsSClnUndsSClnUndsSClnUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'CodeDecl'Unds'StorageDecl'Unds'ParameterDecl{}(Y0:SortCodeDecl{}, Y1:SortStorageDecl{}, Y2:SortParameterDecl{})), Lbl'UndsSClnUndsSClnUndsSClnUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'CodeDecl'Unds'StorageDecl'Unds'ParameterDecl{}(\and{SortCodeDecl{}} (X0:SortCodeDecl{}, Y0:SortCodeDecl{}), \and{SortStorageDecl{}} (X1:SortStorageDecl{}, Y1:SortStorageDecl{}), \and{SortParameterDecl{}} (X2:SortParameterDecl{}, Y2:SortParameterDecl{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortContract{}, \equals{SortContract{}, R} (Val:SortContract{}, Lbl'UndsSClnUndsSClnUndsSClnUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'ParameterDecl'Unds'CodeDecl'Unds'StorageDecl{}(K0:SortParameterDecl{}, K1:SortCodeDecl{}, K2:SortStorageDecl{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortContract{}, \equals{SortContract{}, R} (Val:SortContract{}, Lbl'UndsSClnUndsSClnUndsSClnUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'ParameterDecl'Unds'StorageDecl'Unds'CodeDecl{}(K0:SortParameterDecl{}, K1:SortStorageDecl{}, K2:SortCodeDecl{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortContract{}, \equals{SortContract{}, R} (Val:SortContract{}, Lbl'UndsSClnUndsSClnUndsSClnUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'StorageDecl'Unds'CodeDecl'Unds'ParameterDecl{}(K0:SortStorageDecl{}, K1:SortCodeDecl{}, K2:SortParameterDecl{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortContract{}, \equals{SortContract{}, R} (Val:SortContract{}, Lbl'UndsSClnUndsSClnUndsSClnUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'StorageDecl'Unds'ParameterDecl'Unds'CodeDecl{}(K0:SortStorageDecl{}, K1:SortParameterDecl{}, K2:SortCodeDecl{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortContract{}, \equals{SortContract{}, R} (Val:SortContract{}, Lbl'UndsSClnUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'CodeDecl'Unds'ParameterDecl'Unds'StorageDecl{}(K0:SortCodeDecl{}, K1:SortParameterDecl{}, K2:SortStorageDecl{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortContract{}, \equals{SortContract{}, R} (Val:SortContract{}, Lbl'UndsSClnUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'CodeDecl'Unds'StorageDecl'Unds'ParameterDecl{}(K0:SortCodeDecl{}, K1:SortStorageDecl{}, K2:SortParameterDecl{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortContract{}, \equals{SortContract{}, R} (Val:SortContract{}, Lbl'UndsSClnUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'ParameterDecl'Unds'CodeDecl'Unds'StorageDecl{}(K0:SortParameterDecl{}, K1:SortCodeDecl{}, K2:SortStorageDecl{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortContract{}, \equals{SortContract{}, R} (Val:SortContract{}, Lbl'UndsSClnUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'ParameterDecl'Unds'StorageDecl'Unds'CodeDecl{}(K0:SortParameterDecl{}, K1:SortStorageDecl{}, K2:SortCodeDecl{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortContract{}, \equals{SortContract{}, R} (Val:SortContract{}, Lbl'UndsSClnUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'StorageDecl'Unds'CodeDecl'Unds'ParameterDecl{}(K0:SortStorageDecl{}, K1:SortCodeDecl{}, K2:SortParameterDecl{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortContract{}, \equals{SortContract{}, R} (Val:SortContract{}, Lbl'UndsSClnUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'StorageDecl'Unds'ParameterDecl'Unds'CodeDecl{}(K0:SortStorageDecl{}, K1:SortParameterDecl{}, K2:SortCodeDecl{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBigMapEntryList{}, \equals{SortBigMapEntryList{}, R} (Val:SortBigMapEntryList{}, Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntryList'Unds'BigMapEntry'Unds'BigMapEntryList{}(K0:SortBigMapEntry{}, K1:SortBigMapEntryList{}))) [functional{}()] // functional + axiom{}\implies{SortBigMapEntryList{}} (\and{SortBigMapEntryList{}} (Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntryList'Unds'BigMapEntry'Unds'BigMapEntryList{}(X0:SortBigMapEntry{}, X1:SortBigMapEntryList{}), Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntryList'Unds'BigMapEntry'Unds'BigMapEntryList{}(Y0:SortBigMapEntry{}, Y1:SortBigMapEntryList{})), Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntryList'Unds'BigMapEntry'Unds'BigMapEntryList{}(\and{SortBigMapEntry{}} (X0:SortBigMapEntry{}, Y0:SortBigMapEntry{}), \and{SortBigMapEntryList{}} (X1:SortBigMapEntryList{}, Y1:SortBigMapEntryList{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortDataList{}, \equals{SortDataList{}, R} (Val:SortDataList{}, Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'DataList'Unds'Data'Unds'DataList{}(K0:SortData{}, K1:SortDataList{}))) [functional{}()] // functional + axiom{}\implies{SortDataList{}} (\and{SortDataList{}} (Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'DataList'Unds'Data'Unds'DataList{}(X0:SortData{}, X1:SortDataList{}), Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'DataList'Unds'Data'Unds'DataList{}(Y0:SortData{}, Y1:SortDataList{})), Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'DataList'Unds'Data'Unds'DataList{}(\and{SortData{}} (X0:SortData{}, Y0:SortData{}), \and{SortDataList{}} (X1:SortDataList{}, Y1:SortDataList{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortGroups{}, \equals{SortGroups{}, R} (Val:SortGroups{}, Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Groups'Unds'Group'Unds'Groups{}(K0:SortGroup{}, K1:SortGroups{}))) [functional{}()] // functional + axiom{}\implies{SortGroups{}} (\and{SortGroups{}} (Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Groups'Unds'Group'Unds'Groups{}(X0:SortGroup{}, X1:SortGroups{}), Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Groups'Unds'Group'Unds'Groups{}(Y0:SortGroup{}, Y1:SortGroups{})), Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Groups'Unds'Group'Unds'Groups{}(\and{SortGroup{}} (X0:SortGroup{}, Y0:SortGroup{}), \and{SortGroups{}} (X1:SortGroups{}, Y1:SortGroups{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortMapEntryList{}, \equals{SortMapEntryList{}, R} (Val:SortMapEntryList{}, Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'MapEntryList'Unds'MapEntry'Unds'MapEntryList{}(K0:SortMapEntry{}, K1:SortMapEntryList{}))) [functional{}()] // functional + axiom{}\implies{SortMapEntryList{}} (\and{SortMapEntryList{}} (Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'MapEntryList'Unds'MapEntry'Unds'MapEntryList{}(X0:SortMapEntry{}, X1:SortMapEntryList{}), Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'MapEntryList'Unds'MapEntry'Unds'MapEntryList{}(Y0:SortMapEntry{}, Y1:SortMapEntryList{})), Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'MapEntryList'Unds'MapEntry'Unds'MapEntryList{}(\and{SortMapEntry{}} (X0:SortMapEntry{}, Y0:SortMapEntry{}), \and{SortMapEntryList{}} (X1:SortMapEntryList{}, Y1:SortMapEntryList{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortOtherContractsMapEntryList{}, \equals{SortOtherContractsMapEntryList{}, R} (Val:SortOtherContractsMapEntryList{}, Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OtherContractsMapEntryList'Unds'OtherContractsMapEntry'Unds'OtherContractsMapEntryList{}(K0:SortOtherContractsMapEntry{}, K1:SortOtherContractsMapEntryList{}))) [functional{}()] // functional + axiom{}\implies{SortOtherContractsMapEntryList{}} (\and{SortOtherContractsMapEntryList{}} (Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OtherContractsMapEntryList'Unds'OtherContractsMapEntry'Unds'OtherContractsMapEntryList{}(X0:SortOtherContractsMapEntry{}, X1:SortOtherContractsMapEntryList{}), Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OtherContractsMapEntryList'Unds'OtherContractsMapEntry'Unds'OtherContractsMapEntryList{}(Y0:SortOtherContractsMapEntry{}, Y1:SortOtherContractsMapEntryList{})), Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OtherContractsMapEntryList'Unds'OtherContractsMapEntry'Unds'OtherContractsMapEntryList{}(\and{SortOtherContractsMapEntry{}} (X0:SortOtherContractsMapEntry{}, Y0:SortOtherContractsMapEntry{}), \and{SortOtherContractsMapEntryList{}} (X1:SortOtherContractsMapEntryList{}, Y1:SortOtherContractsMapEntryList{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortStack{}, \equals{SortStack{}, R} (Val:SortStack{}, Lbl'UndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack{}(K0:SortStackElement{}, K1:SortStack{}))) [functional{}()] // functional + axiom{}\implies{SortStack{}} (\and{SortStack{}} (Lbl'UndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack{}(X0:SortStackElement{}, X1:SortStack{}), Lbl'UndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack{}(Y0:SortStackElement{}, Y1:SortStack{})), Lbl'UndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack{}(\and{SortStackElement{}} (X0:SortStackElement{}, Y0:SortStackElement{}), \and{SortStack{}} (X1:SortStack{}, Y1:SortStack{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortBlockList{}, \equals{SortBlockList{}, R} (Val:SortBlockList{}, Lbl'UndsSClnUndsUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockList'Unds'Block'Unds'BlockList{}(K0:SortBlock{}, K1:SortBlockList{}))) [functional{}()] // functional + axiom{}\implies{SortBlockList{}} (\and{SortBlockList{}} (Lbl'UndsSClnUndsUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockList'Unds'Block'Unds'BlockList{}(X0:SortBlock{}, X1:SortBlockList{}), Lbl'UndsSClnUndsUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockList'Unds'Block'Unds'BlockList{}(Y0:SortBlock{}, Y1:SortBlockList{})), Lbl'UndsSClnUndsUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockList'Unds'Block'Unds'BlockList{}(\and{SortBlock{}} (X0:SortBlock{}, Y0:SortBlock{}), \and{SortBlockList{}} (X1:SortBlockList{}, Y1:SortBlockList{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortStackElementList{}, \equals{SortStackElementList{}, R} (Val:SortStackElementList{}, Lbl'UndsSClnUndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'StackElementList'Unds'StackElementLiteral'Unds'StackElementList{}(K0:SortStackElementLiteral{}, K1:SortStackElementList{}))) [functional{}()] // functional + axiom{}\implies{SortStackElementList{}} (\and{SortStackElementList{}} (Lbl'UndsSClnUndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'StackElementList'Unds'StackElementLiteral'Unds'StackElementList{}(X0:SortStackElementLiteral{}, X1:SortStackElementList{}), Lbl'UndsSClnUndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'StackElementList'Unds'StackElementLiteral'Unds'StackElementList{}(Y0:SortStackElementLiteral{}, Y1:SortStackElementList{})), Lbl'UndsSClnUndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'StackElementList'Unds'StackElementLiteral'Unds'StackElementList{}(\and{SortStackElementLiteral{}} (X0:SortStackElementLiteral{}, Y0:SortStackElementLiteral{}), \and{SortStackElementList{}} (X1:SortStackElementList{}, Y1:SortStackElementList{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'Unds-LT-Eqls'Int'Unds'{}(K0:SortInt{}, K1:SortInt{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'Unds-LT-Eqls'Map'UndsUnds'MAP'Unds'Bool'Unds'Map'Unds'Map{}(K0:SortMap{}, K1:SortMap{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'Unds-LT-Eqls'Set'UndsUnds'SET'Unds'Bool'Unds'Set'Unds'Set{}(K0:SortSet{}, K1:SortSet{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'Unds-LT-Eqls'String'UndsUnds'STRING-COMMON'Unds'Bool'Unds'String'Unds'String{}(K0:SortString{}, K1:SortString{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'Unds-LT-'Int'Unds'{}(K0:SortInt{}, K1:SortInt{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'Unds-LT-'String'UndsUnds'STRING-COMMON'Unds'Bool'Unds'String'Unds'String{}(K0:SortString{}, K1:SortString{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'UndsEqlsSlshEqls'Bool'Unds'{}(K0:SortBool{}, K1:SortBool{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'UndsEqlsSlshEqls'Int'Unds'{}(K0:SortInt{}, K1:SortInt{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'UndsEqlsSlshEqls'K'Unds'{}(K0:SortK{}, K1:SortK{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'UndsEqlsSlshEqls'String'UndsUnds'STRING-COMMON'Unds'Bool'Unds'String'Unds'String{}(K0:SortString{}, K1:SortString{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'UndsEqlsEqls'Bool'Unds'{}(K0:SortBool{}, K1:SortBool{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'UndsEqlsEqls'Int'Unds'{}(K0:SortInt{}, K1:SortInt{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'UndsEqlsEqls'K'Unds'{}(K0:SortK{}, K1:SortK{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'UndsEqlsEqls'String'UndsUnds'STRING-COMMON'Unds'Bool'Unds'String'Unds'String{}(K0:SortString{}, K1:SortString{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBoolExp{}, \equals{SortBoolExp{}, R} (Val:SortBoolExp{}, Lbl'UndsEqlsEqlsUndsUnds'MICHELSON'Unds'BoolExp'Unds'KItem'Unds'Data{}(K0:SortKItem{}, K1:SortData{}))) [functional{}()] // functional + axiom{}\implies{SortBoolExp{}} (\and{SortBoolExp{}} (Lbl'UndsEqlsEqlsUndsUnds'MICHELSON'Unds'BoolExp'Unds'KItem'Unds'Data{}(X0:SortKItem{}, X1:SortData{}), Lbl'UndsEqlsEqlsUndsUnds'MICHELSON'Unds'BoolExp'Unds'KItem'Unds'Data{}(Y0:SortKItem{}, Y1:SortData{})), Lbl'UndsEqlsEqlsUndsUnds'MICHELSON'Unds'BoolExp'Unds'KItem'Unds'Data{}(\and{SortKItem{}} (X0:SortKItem{}, Y0:SortKItem{}), \and{SortData{}} (X1:SortData{}, Y1:SortData{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'Unds-GT-Eqls'Int'Unds'{}(K0:SortInt{}, K1:SortInt{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'Unds-GT-Eqls'String'UndsUnds'STRING-COMMON'Unds'Bool'Unds'String'Unds'String{}(K0:SortString{}, K1:SortString{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'Unds-GT-'Int'Unds'{}(K0:SortInt{}, K1:SortInt{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'Unds-GT-'String'UndsUnds'STRING-COMMON'Unds'Bool'Unds'String'Unds'String{}(K0:SortString{}, K1:SortString{}))) [functional{}()] // functional + axiom{R} \equals{SortList{}, R} (Lbl'Unds'List'Unds'{}(Lbl'Unds'List'Unds'{}(K1:SortList{},K2:SortList{}),K3:SortList{}),Lbl'Unds'List'Unds'{}(K1:SortList{},Lbl'Unds'List'Unds'{}(K2:SortList{},K3:SortList{}))) [assoc{}()] // associativity + axiom{R}\equals{SortList{}, R} (Lbl'Unds'List'Unds'{}(K:SortList{},Lbl'Stop'List{}()),K:SortList{}) [unit{}()] // right unit + axiom{R}\equals{SortList{}, R} (Lbl'Unds'List'Unds'{}(Lbl'Stop'List{}(),K:SortList{}),K:SortList{}) [unit{}()] // left unit + axiom{R} \exists{R} (Val:SortList{}, \equals{SortList{}, R} (Val:SortList{}, Lbl'Unds'List'Unds'{}(K0:SortList{}, K1:SortList{}))) [functional{}()] // functional + axiom{R} \equals{SortMap{}, R} (Lbl'Unds'Map'Unds'{}(Lbl'Unds'Map'Unds'{}(K1:SortMap{},K2:SortMap{}),K3:SortMap{}),Lbl'Unds'Map'Unds'{}(K1:SortMap{},Lbl'Unds'Map'Unds'{}(K2:SortMap{},K3:SortMap{}))) [assoc{}()] // associativity + axiom{R} \equals{SortMap{}, R} (Lbl'Unds'Map'Unds'{}(K1:SortMap{},K2:SortMap{}),Lbl'Unds'Map'Unds'{}(K2:SortMap{},K1:SortMap{})) [comm{}()] // commutativity + axiom{R}\equals{SortMap{}, R} (Lbl'Unds'Map'Unds'{}(K:SortMap{},Lbl'Stop'Map{}()),K:SortMap{}) [unit{}()] // right unit + axiom{R}\equals{SortMap{}, R} (Lbl'Unds'Map'Unds'{}(Lbl'Stop'Map{}(),K:SortMap{}),K:SortMap{}) [unit{}()] // left unit + axiom{R} \equals{SortSet{}, R} (Lbl'Unds'Set'Unds'{}(Lbl'Unds'Set'Unds'{}(K1:SortSet{},K2:SortSet{}),K3:SortSet{}),Lbl'Unds'Set'Unds'{}(K1:SortSet{},Lbl'Unds'Set'Unds'{}(K2:SortSet{},K3:SortSet{}))) [assoc{}()] // associativity + axiom{R} \equals{SortSet{}, R} (Lbl'Unds'Set'Unds'{}(K1:SortSet{},K2:SortSet{}),Lbl'Unds'Set'Unds'{}(K2:SortSet{},K1:SortSet{})) [comm{}()] // commutativity + axiom{R} \equals{SortSet{}, R} (Lbl'Unds'Set'Unds'{}(K:SortSet{},K:SortSet{}),K:SortSet{}) [idem{}()] // idempotency + axiom{R}\equals{SortSet{}, R} (Lbl'Unds'Set'Unds'{}(K:SortSet{},Lbl'Stop'Set{}()),K:SortSet{}) [unit{}()] // right unit + axiom{R}\equals{SortSet{}, R} (Lbl'Unds'Set'Unds'{}(Lbl'Stop'Set{}(),K:SortSet{}),K:SortSet{}) [unit{}()] // left unit + axiom{R} \exists{R} (Val:SortSet{}, \equals{SortSet{}, R} (Val:SortSet{}, Lbl'Unds'Set'Unds'{}(K0:SortSet{}, K1:SortSet{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortMap{}, \equals{SortMap{}, R} (Val:SortMap{}, Lbl'UndsLSqBUnds-LT-'-undef'RSqB'{}(K0:SortMap{}, K1:SortKItem{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortKItem{}, \equals{SortKItem{}, R} (Val:SortKItem{}, Lbl'UndsLSqBUndsRSqB'orDefault'UndsUnds'MAP'Unds'KItem'Unds'Map'Unds'KItem'Unds'KItem{}(K0:SortMap{}, K1:SortKItem{}, K2:SortKItem{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortAnnotationList{}, \equals{SortAnnotationList{}, R} (Val:SortAnnotationList{}, Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList{}(K0:SortAnnotation{}, K1:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortAnnotationList{}} (\and{SortAnnotationList{}} (Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList{}(X0:SortAnnotation{}, X1:SortAnnotationList{}), Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList{}(Y0:SortAnnotation{}, Y1:SortAnnotationList{})), Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList{}(\and{SortAnnotation{}} (X0:SortAnnotation{}, Y0:SortAnnotation{}), \and{SortAnnotationList{}} (X1:SortAnnotationList{}, Y1:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortType{}, \equals{SortType{}, R} (Val:SortType{}, Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(K0:SortNullaryTypeName{}, K1:SortAnnotationList{}))) [functional{}()] // functional + axiom{}\implies{SortType{}} (\and{SortType{}} (Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(X0:SortNullaryTypeName{}, X1:SortAnnotationList{}), Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(Y0:SortNullaryTypeName{}, Y1:SortAnnotationList{})), Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(\and{SortNullaryTypeName{}} (X0:SortNullaryTypeName{}, Y0:SortNullaryTypeName{}), \and{SortAnnotationList{}} (X1:SortAnnotationList{}, Y1:SortAnnotationList{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortType{}} (\and{SortType{}} (Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(X0:SortNullaryTypeName{}, X1:SortAnnotationList{}), Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Y0:SortUnaryTypeName{}, Y1:SortAnnotationList{}, Y2:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{}\not{SortType{}} (\and{SortType{}} (Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(X0:SortNullaryTypeName{}, X1:SortAnnotationList{}), Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortBinaryTypeName{}, Y1:SortAnnotationList{}, Y2:SortType{}, Y3:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortTypeName{}, \equals{SortTypeName{}, R} (Val:SortTypeName{}, Lbl'UndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'UnaryTypeName'Unds'TypeName{}(K0:SortUnaryTypeName{}, K1:SortTypeName{}))) [functional{}()] // functional + axiom{}\implies{SortTypeName{}} (\and{SortTypeName{}} (Lbl'UndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'UnaryTypeName'Unds'TypeName{}(X0:SortUnaryTypeName{}, X1:SortTypeName{}), Lbl'UndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'UnaryTypeName'Unds'TypeName{}(Y0:SortUnaryTypeName{}, Y1:SortTypeName{})), Lbl'UndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'UnaryTypeName'Unds'TypeName{}(\and{SortUnaryTypeName{}} (X0:SortUnaryTypeName{}, Y0:SortUnaryTypeName{}), \and{SortTypeName{}} (X1:SortTypeName{}, Y1:SortTypeName{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortTypeName{}} (\and{SortTypeName{}} (Lbl'UndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'UnaryTypeName'Unds'TypeName{}(X0:SortUnaryTypeName{}, X1:SortTypeName{}), Lbl'UndsUndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'BinaryTypeName'Unds'TypeName'Unds'TypeName{}(Y0:SortBinaryTypeName{}, Y1:SortTypeName{}, Y2:SortTypeName{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortType{}, \equals{SortType{}, R} (Val:SortType{}, Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(K0:SortUnaryTypeName{}, K1:SortAnnotationList{}, K2:SortType{}))) [functional{}()] // functional + axiom{}\implies{SortType{}} (\and{SortType{}} (Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(X0:SortUnaryTypeName{}, X1:SortAnnotationList{}, X2:SortType{}), Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Y0:SortUnaryTypeName{}, Y1:SortAnnotationList{}, Y2:SortType{})), Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(\and{SortUnaryTypeName{}} (X0:SortUnaryTypeName{}, Y0:SortUnaryTypeName{}), \and{SortAnnotationList{}} (X1:SortAnnotationList{}, Y1:SortAnnotationList{}), \and{SortType{}} (X2:SortType{}, Y2:SortType{}))) [constructor{}()] // no confusion same constructor + axiom{}\not{SortType{}} (\and{SortType{}} (Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(X0:SortUnaryTypeName{}, X1:SortAnnotationList{}, X2:SortType{}), Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortBinaryTypeName{}, Y1:SortAnnotationList{}, Y2:SortType{}, Y3:SortType{}))) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortTypeName{}, \equals{SortTypeName{}, R} (Val:SortTypeName{}, Lbl'UndsUndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'BinaryTypeName'Unds'TypeName'Unds'TypeName{}(K0:SortBinaryTypeName{}, K1:SortTypeName{}, K2:SortTypeName{}))) [functional{}()] // functional + axiom{}\implies{SortTypeName{}} (\and{SortTypeName{}} (Lbl'UndsUndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'BinaryTypeName'Unds'TypeName'Unds'TypeName{}(X0:SortBinaryTypeName{}, X1:SortTypeName{}, X2:SortTypeName{}), Lbl'UndsUndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'BinaryTypeName'Unds'TypeName'Unds'TypeName{}(Y0:SortBinaryTypeName{}, Y1:SortTypeName{}, Y2:SortTypeName{})), Lbl'UndsUndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'BinaryTypeName'Unds'TypeName'Unds'TypeName{}(\and{SortBinaryTypeName{}} (X0:SortBinaryTypeName{}, Y0:SortBinaryTypeName{}), \and{SortTypeName{}} (X1:SortTypeName{}, Y1:SortTypeName{}), \and{SortTypeName{}} (X2:SortTypeName{}, Y2:SortTypeName{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortType{}, \equals{SortType{}, R} (Val:SortType{}, Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(K0:SortBinaryTypeName{}, K1:SortAnnotationList{}, K2:SortType{}, K3:SortType{}))) [functional{}()] // functional + axiom{}\implies{SortType{}} (\and{SortType{}} (Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortBinaryTypeName{}, X1:SortAnnotationList{}, X2:SortType{}, X3:SortType{}), Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(Y0:SortBinaryTypeName{}, Y1:SortAnnotationList{}, Y2:SortType{}, Y3:SortType{})), Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(\and{SortBinaryTypeName{}} (X0:SortBinaryTypeName{}, Y0:SortBinaryTypeName{}), \and{SortAnnotationList{}} (X1:SortAnnotationList{}, Y1:SortAnnotationList{}), \and{SortType{}} (X2:SortType{}, Y2:SortType{}), \and{SortType{}} (X3:SortType{}, Y3:SortType{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'Unds'andBool'Unds'{}(K0:SortBool{}, K1:SortBool{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'Unds'andThenBool'Unds'{}(K0:SortBool{}, K1:SortBool{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'Unds'impliesBool'Unds'{}(K0:SortBool{}, K1:SortBool{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'Unds'in'UndsUnds'LIST'Unds'Bool'Unds'KItem'Unds'List{}(K0:SortKItem{}, K1:SortList{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'Unds'in'Unds'keys'LParUndsRParUnds'MAP'Unds'Bool'Unds'KItem'Unds'Map{}(K0:SortKItem{}, K1:SortMap{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'Unds'orBool'UndsUnds'BOOL'Unds'Bool'Unds'Bool'Unds'Bool{}(K0:SortBool{}, K1:SortBool{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'Unds'orElseBool'Unds'{}(K0:SortBool{}, K1:SortBool{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, Lbl'Unds'xorBool'Unds'{}(K0:SortBool{}, K1:SortBool{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInt{}, \equals{SortInt{}, R} (Val:SortInt{}, Lbl'Unds'xorInt'Unds'{}(K0:SortInt{}, K1:SortInt{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInvariant{}, \equals{SortInvariant{}, R} (Val:SortInvariant{}, Lbl'UndsLBraUndsRBraUnds'SYMBOLIC-UNIT-TEST-COMMON-SYNTAX'Unds'Invariant'Unds'LiteralStack'Unds'BlockList{}(K0:SortLiteralStack{}, K1:SortBlockList{}))) [functional{}()] // functional + axiom{}\implies{SortInvariant{}} (\and{SortInvariant{}} (Lbl'UndsLBraUndsRBraUnds'SYMBOLIC-UNIT-TEST-COMMON-SYNTAX'Unds'Invariant'Unds'LiteralStack'Unds'BlockList{}(X0:SortLiteralStack{}, X1:SortBlockList{}), Lbl'UndsLBraUndsRBraUnds'SYMBOLIC-UNIT-TEST-COMMON-SYNTAX'Unds'Invariant'Unds'LiteralStack'Unds'BlockList{}(Y0:SortLiteralStack{}, Y1:SortBlockList{})), Lbl'UndsLBraUndsRBraUnds'SYMBOLIC-UNIT-TEST-COMMON-SYNTAX'Unds'Invariant'Unds'LiteralStack'Unds'BlockList{}(\and{SortLiteralStack{}} (X0:SortLiteralStack{}, Y0:SortLiteralStack{}), \and{SortBlockList{}} (X1:SortBlockList{}, Y1:SortBlockList{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortMap{}, \equals{SortMap{}, R} (Val:SortMap{}, Lbl'UndsPipe'-'-GT-Unds'{}(K0:SortKItem{}, K1:SortKItem{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInt{}, \equals{SortInt{}, R} (Val:SortInt{}, Lbl'UndsPipe'Int'Unds'{}(K0:SortInt{}, K1:SortInt{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortSet{}, \equals{SortSet{}, R} (Val:SortSet{}, Lbl'UndsPipe'Set'UndsUnds'SET'Unds'Set'Unds'Set'Unds'Set{}(K0:SortSet{}, K1:SortSet{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInt{}, \equals{SortInt{}, R} (Val:SortInt{}, LblabsInt'LParUndsRParUnds'INT-COMMON'Unds'Int'Unds'Int{}(K0:SortInt{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortNullaryTypeName{}, \equals{SortNullaryTypeName{}, R} (Val:SortNullaryTypeName{}, Lbladdress'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [functional{}()] // functional + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lbladdress'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblbool'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lbladdress'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblbytes'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lbladdress'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblchain'Unds'id'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lbladdress'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblkey'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lbladdress'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblkey'Unds'hash'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lbladdress'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblmutez'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lbladdress'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lbloperation'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lbladdress'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblsignature'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lbladdress'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblstring'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lbladdress'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lbltimestamp'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lbladdress'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblunit'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortAmountGroup{}, \equals{SortAmountGroup{}, R} (Val:SortAmountGroup{}, Lblamount'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AmountGroup'Unds'Int{}(K0:SortInt{}))) [functional{}()] // functional + axiom{}\implies{SortAmountGroup{}} (\and{SortAmountGroup{}} (Lblamount'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AmountGroup'Unds'Int{}(X0:SortInt{}), Lblamount'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AmountGroup'Unds'Int{}(Y0:SortInt{})), Lblamount'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AmountGroup'Unds'Int{}(\and{SortInt{}} (X0:SortInt{}, Y0:SortInt{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortBalanceGroup{}, \equals{SortBalanceGroup{}, R} (Val:SortBalanceGroup{}, Lblbalance'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BalanceGroup'Unds'Int{}(K0:SortInt{}))) [functional{}()] // functional + axiom{}\implies{SortBalanceGroup{}} (\and{SortBalanceGroup{}} (Lblbalance'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BalanceGroup'Unds'Int{}(X0:SortInt{}), Lblbalance'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BalanceGroup'Unds'Int{}(Y0:SortInt{})), Lblbalance'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BalanceGroup'Unds'Int{}(\and{SortInt{}} (X0:SortInt{}, Y0:SortInt{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortEndianness{}, \equals{SortEndianness{}, R} (Val:SortEndianness{}, LblbigEndianBytes{}())) [functional{}()] // functional + axiom{}\not{SortEndianness{}} (\and{SortEndianness{}} (LblbigEndianBytes{}(), LbllittleEndianBytes{}())) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortMapTypeName{}, \equals{SortMapTypeName{}, R} (Val:SortMapTypeName{}, Lblbig'Unds'map'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}())) [functional{}()] // functional + axiom{}\not{SortMapTypeName{}} (\and{SortMapTypeName{}} (Lblbig'Unds'map'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}(), Lblmap'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortBigMapGroup{}, \equals{SortBigMapGroup{}, R} (Val:SortBigMapGroup{}, Lblbig'Unds'maps'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapGroup'Unds'BigMapEntryList{}(K0:SortBigMapEntryList{}))) [functional{}()] // functional + axiom{}\implies{SortBigMapGroup{}} (\and{SortBigMapGroup{}} (Lblbig'Unds'maps'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapGroup'Unds'BigMapEntryList{}(X0:SortBigMapEntryList{}), Lblbig'Unds'maps'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapGroup'Unds'BigMapEntryList{}(Y0:SortBigMapEntryList{})), Lblbig'Unds'maps'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapGroup'Unds'BigMapEntryList{}(\and{SortBigMapEntryList{}} (X0:SortBigMapEntryList{}, Y0:SortBigMapEntryList{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortNullaryTypeName{}, \equals{SortNullaryTypeName{}, R} (Val:SortNullaryTypeName{}, Lblbool'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [functional{}()] // functional + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblbool'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblbytes'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblbool'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblchain'Unds'id'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblbool'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblkey'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblbool'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblkey'Unds'hash'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblbool'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblmutez'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblbool'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lbloperation'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblbool'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblsignature'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblbool'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblstring'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblbool'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lbltimestamp'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblbool'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblunit'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortNullaryTypeName{}, \equals{SortNullaryTypeName{}, R} (Val:SortNullaryTypeName{}, Lblbytes'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [functional{}()] // functional + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblbytes'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblchain'Unds'id'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblbytes'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblkey'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblbytes'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblkey'Unds'hash'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblbytes'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblmutez'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblbytes'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lbloperation'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblbytes'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblsignature'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblbytes'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblstring'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblbytes'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lbltimestamp'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblbytes'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblunit'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortNullaryTypeName{}, \equals{SortNullaryTypeName{}, R} (Val:SortNullaryTypeName{}, Lblchain'Unds'id'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [functional{}()] // functional + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblchain'Unds'id'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblkey'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblchain'Unds'id'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblkey'Unds'hash'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblchain'Unds'id'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblmutez'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblchain'Unds'id'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lbloperation'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblchain'Unds'id'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblsignature'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblchain'Unds'id'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblstring'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblchain'Unds'id'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lbltimestamp'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblchain'Unds'id'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblunit'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortChainGroup{}, \equals{SortChainGroup{}, R} (Val:SortChainGroup{}, Lblchain'Unds'id'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'ChainGroup'Unds'MBytes{}(K0:SortMBytes{}))) [functional{}()] // functional + axiom{}\implies{SortChainGroup{}} (\and{SortChainGroup{}} (Lblchain'Unds'id'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'ChainGroup'Unds'MBytes{}(X0:SortMBytes{}), Lblchain'Unds'id'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'ChainGroup'Unds'MBytes{}(Y0:SortMBytes{})), Lblchain'Unds'id'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'ChainGroup'Unds'MBytes{}(\and{SortMBytes{}} (X0:SortMBytes{}, Y0:SortMBytes{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortCodeDecl{}, \equals{SortCodeDecl{}, R} (Val:SortCodeDecl{}, Lblcode'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'CodeDecl'Unds'Block{}(K0:SortBlock{}))) [functional{}()] // functional + axiom{}\implies{SortCodeDecl{}} (\and{SortCodeDecl{}} (Lblcode'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'CodeDecl'Unds'Block{}(X0:SortBlock{}), Lblcode'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'CodeDecl'Unds'Block{}(Y0:SortBlock{})), Lblcode'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'CodeDecl'Unds'Block{}(\and{SortBlock{}} (X0:SortBlock{}, Y0:SortBlock{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortUnaryTypeName{}, \equals{SortUnaryTypeName{}, R} (Val:SortUnaryTypeName{}, Lblcontract'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}())) [functional{}()] // functional + axiom{}\not{SortUnaryTypeName{}} (\and{SortUnaryTypeName{}} (Lblcontract'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(), Lbllist'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortUnaryTypeName{}} (\and{SortUnaryTypeName{}} (Lblcontract'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(), Lbloption'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortUnaryTypeName{}} (\and{SortUnaryTypeName{}} (Lblcontract'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(), Lblset'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortContractGroup{}, \equals{SortContractGroup{}, R} (Val:SortContractGroup{}, Lblcontract'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'ContractGroup'Unds'Contract{}(K0:SortContract{}))) [functional{}()] // functional + axiom{}\implies{SortContractGroup{}} (\and{SortContractGroup{}} (Lblcontract'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'ContractGroup'Unds'Contract{}(X0:SortContract{}), Lblcontract'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'ContractGroup'Unds'Contract{}(Y0:SortContract{})), Lblcontract'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'ContractGroup'Unds'Contract{}(\and{SortContract{}} (X0:SortContract{}, Y0:SortContract{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortInt{}, \equals{SortInt{}, R} (Val:SortInt{}, LblcountAllOccurrences'LParUndsCommUndsRParUnds'STRING-COMMON'Unds'Int'Unds'String'Unds'String{}(K0:SortString{}, K1:SortString{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortId{}, \equals{SortId{}, R} (Val:SortId{}, LblfreshId'LParUndsRParUnds'ID-COMMON'Unds'Id'Unds'Int{}(K0:SortInt{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInt{}, \equals{SortInt{}, R} (Val:SortInt{}, LblfreshInt'LParUndsRParUnds'INT'Unds'Int'Unds'Int{}(K0:SortInt{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortGroups{}, \equals{SortGroups{}, R} (Val:SortGroups{}, LblgroupSemicolon{}(K0:SortGroup{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInputGroup{}, \equals{SortInputGroup{}, R} (Val:SortInputGroup{}, Lblinput'UndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'InputGroup'Unds'LiteralStack{}(K0:SortLiteralStack{}))) [functional{}()] // functional + axiom{}\implies{SortInputGroup{}} (\and{SortInputGroup{}} (Lblinput'UndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'InputGroup'Unds'LiteralStack{}(X0:SortLiteralStack{}), Lblinput'UndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'InputGroup'Unds'LiteralStack{}(Y0:SortLiteralStack{})), Lblinput'UndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'InputGroup'Unds'LiteralStack{}(\and{SortLiteralStack{}} (X0:SortLiteralStack{}, Y0:SortLiteralStack{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortNumTypeName{}, \equals{SortNumTypeName{}, R} (Val:SortNumTypeName{}, Lblint'Unds'MICHELSON-COMMON-SYNTAX'Unds'NumTypeName{}())) [functional{}()] // functional + axiom{}\not{SortNumTypeName{}} (\and{SortNumTypeName{}} (Lblint'Unds'MICHELSON-COMMON-SYNTAX'Unds'NumTypeName{}(), Lblnat'Unds'MICHELSON-COMMON-SYNTAX'Unds'NumTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortSet{}, \equals{SortSet{}, R} (Val:SortSet{}, LblintersectSet'LParUndsCommUndsRParUnds'SET'Unds'Set'Unds'Set'Unds'Set{}(K0:SortSet{}, K1:SortSet{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInvariantsGroup{}, \equals{SortInvariantsGroup{}, R} (Val:SortInvariantsGroup{}, Lblinvariant'UndsUndsUnds'SYMBOLIC-UNIT-TEST-COMMON-SYNTAX'Unds'InvariantsGroup'Unds'VariableAnnotation'Unds'Invariant{}(K0:SortVariableAnnotation{}, K1:SortInvariant{}))) [functional{}()] // functional + axiom{}\implies{SortInvariantsGroup{}} (\and{SortInvariantsGroup{}} (Lblinvariant'UndsUndsUnds'SYMBOLIC-UNIT-TEST-COMMON-SYNTAX'Unds'InvariantsGroup'Unds'VariableAnnotation'Unds'Invariant{}(X0:SortVariableAnnotation{}, X1:SortInvariant{}), Lblinvariant'UndsUndsUnds'SYMBOLIC-UNIT-TEST-COMMON-SYNTAX'Unds'InvariantsGroup'Unds'VariableAnnotation'Unds'Invariant{}(Y0:SortVariableAnnotation{}, Y1:SortInvariant{})), Lblinvariant'UndsUndsUnds'SYMBOLIC-UNIT-TEST-COMMON-SYNTAX'Unds'InvariantsGroup'Unds'VariableAnnotation'Unds'Invariant{}(\and{SortVariableAnnotation{}} (X0:SortVariableAnnotation{}, Y0:SortVariableAnnotation{}), \and{SortInvariant{}} (X1:SortInvariant{}, Y1:SortInvariant{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, LblisValue'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'Data{}(K0:SortData{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, LblisValue'LParUndsCommUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName'Unds'Data{}(K0:SortTypeName{}, K1:SortData{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortNullaryTypeName{}, \equals{SortNullaryTypeName{}, R} (Val:SortNullaryTypeName{}, Lblkey'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [functional{}()] // functional + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblkey'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblkey'Unds'hash'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblkey'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblmutez'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblkey'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lbloperation'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblkey'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblsignature'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblkey'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblstring'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblkey'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lbltimestamp'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblkey'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblunit'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortNullaryTypeName{}, \equals{SortNullaryTypeName{}, R} (Val:SortNullaryTypeName{}, Lblkey'Unds'hash'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [functional{}()] // functional + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblkey'Unds'hash'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblmutez'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblkey'Unds'hash'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lbloperation'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblkey'Unds'hash'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblsignature'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblkey'Unds'hash'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblstring'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblkey'Unds'hash'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lbltimestamp'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblkey'Unds'hash'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblunit'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortSet{}, \equals{SortSet{}, R} (Val:SortSet{}, Lblkeys'LParUndsRParUnds'MAP'Unds'Set'Unds'Map{}(K0:SortMap{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBinaryTypeName{}, \equals{SortBinaryTypeName{}, R} (Val:SortBinaryTypeName{}, Lbllambda'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}())) [functional{}()] // functional + axiom{}\not{SortBinaryTypeName{}} (\and{SortBinaryTypeName{}} (Lbllambda'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}(), Lblor'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortBinaryTypeName{}} (\and{SortBinaryTypeName{}} (Lbllambda'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}(), Lblpair'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInt{}, \equals{SortInt{}, R} (Val:SortInt{}, LbllengthBytes'LParUndsRParUnds'BYTES-HOOKED'Unds'Int'Unds'Bytes{}(K0:SortBytes{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInt{}, \equals{SortInt{}, R} (Val:SortInt{}, LbllengthString'LParUndsRParUnds'STRING-COMMON'Unds'Int'Unds'String{}(K0:SortString{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortUnaryTypeName{}, \equals{SortUnaryTypeName{}, R} (Val:SortUnaryTypeName{}, Lbllist'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}())) [functional{}()] // functional + axiom{}\not{SortUnaryTypeName{}} (\and{SortUnaryTypeName{}} (Lbllist'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(), Lbloption'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortUnaryTypeName{}} (\and{SortUnaryTypeName{}} (Lbllist'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(), Lblset'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortEndianness{}, \equals{SortEndianness{}, R} (Val:SortEndianness{}, LbllittleEndianBytes{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortMapTypeName{}, \equals{SortMapTypeName{}, R} (Val:SortMapTypeName{}, Lblmap'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInt{}, \equals{SortInt{}, R} (Val:SortInt{}, LblmaxInt'LParUndsCommUndsRParUnds'INT-COMMON'Unds'Int'Unds'Int'Unds'Int{}(K0:SortInt{}, K1:SortInt{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInt{}, \equals{SortInt{}, R} (Val:SortInt{}, LblminInt'LParUndsCommUndsRParUnds'INT-COMMON'Unds'Int'Unds'Int'Unds'Int{}(K0:SortInt{}, K1:SortInt{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortNullaryTypeName{}, \equals{SortNullaryTypeName{}, R} (Val:SortNullaryTypeName{}, Lblmutez'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [functional{}()] // functional + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblmutez'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lbloperation'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblmutez'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblsignature'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblmutez'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblstring'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblmutez'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lbltimestamp'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblmutez'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblunit'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortNumTypeName{}, \equals{SortNumTypeName{}, R} (Val:SortNumTypeName{}, Lblnat'Unds'MICHELSON-COMMON-SYNTAX'Unds'NumTypeName{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortAssumeFailedCellOpt{}, \equals{SortAssumeFailedCellOpt{}, R} (Val:SortAssumeFailedCellOpt{}, LblnoAssumeFailedCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBigmapsCellOpt{}, \equals{SortBigmapsCellOpt{}, R} (Val:SortBigmapsCellOpt{}, LblnoBigmapsCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortCutpointsCellOpt{}, \equals{SortCutpointsCellOpt{}, R} (Val:SortCutpointsCellOpt{}, LblnoCutpointsCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortExpectedCellOpt{}, \equals{SortExpectedCellOpt{}, R} (Val:SortExpectedCellOpt{}, LblnoExpectedCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortGeneratedCounterCellOpt{}, \equals{SortGeneratedCounterCellOpt{}, R} (Val:SortGeneratedCounterCellOpt{}, LblnoGeneratedCounterCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInputstackCellOpt{}, \equals{SortInputstackCellOpt{}, R} (Val:SortInputstackCellOpt{}, LblnoInputstackCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInvsCellOpt{}, \equals{SortInvsCellOpt{}, R} (Val:SortInvsCellOpt{}, LblnoInvsCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortKCellOpt{}, \equals{SortKCellOpt{}, R} (Val:SortKCellOpt{}, LblnoKCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortKnownaddrsCellOpt{}, \equals{SortKnownaddrsCellOpt{}, R} (Val:SortKnownaddrsCellOpt{}, LblnoKnownaddrsCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortMichelsonTopCellOpt{}, \equals{SortMichelsonTopCellOpt{}, R} (Val:SortMichelsonTopCellOpt{}, LblnoMichelsonTopCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortMyaddrCellOpt{}, \equals{SortMyaddrCellOpt{}, R} (Val:SortMyaddrCellOpt{}, LblnoMyaddrCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortMyamountCellOpt{}, \equals{SortMyamountCellOpt{}, R} (Val:SortMyamountCellOpt{}, LblnoMyamountCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortMybalanceCellOpt{}, \equals{SortMybalanceCellOpt{}, R} (Val:SortMybalanceCellOpt{}, LblnoMybalanceCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortMychainidCellOpt{}, \equals{SortMychainidCellOpt{}, R} (Val:SortMychainidCellOpt{}, LblnoMychainidCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortMynowCellOpt{}, \equals{SortMynowCellOpt{}, R} (Val:SortMynowCellOpt{}, LblnoMynowCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortNonceCellOpt{}, \equals{SortNonceCellOpt{}, R} (Val:SortNonceCellOpt{}, LblnoNonceCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortParamtypeCellOpt{}, \equals{SortParamtypeCellOpt{}, R} (Val:SortParamtypeCellOpt{}, LblnoParamtypeCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortParamvalueCellOpt{}, \equals{SortParamvalueCellOpt{}, R} (Val:SortParamvalueCellOpt{}, LblnoParamvalueCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortPostCellOpt{}, \equals{SortPostCellOpt{}, R} (Val:SortPostCellOpt{}, LblnoPostCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortPreCellOpt{}, \equals{SortPreCellOpt{}, R} (Val:SortPreCellOpt{}, LblnoPreCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortReturncodeCellOpt{}, \equals{SortReturncodeCellOpt{}, R} (Val:SortReturncodeCellOpt{}, LblnoReturncodeCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortScriptCellOpt{}, \equals{SortScriptCellOpt{}, R} (Val:SortScriptCellOpt{}, LblnoScriptCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortSenderaddrCellOpt{}, \equals{SortSenderaddrCellOpt{}, R} (Val:SortSenderaddrCellOpt{}, LblnoSenderaddrCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortSourceaddrCellOpt{}, \equals{SortSourceaddrCellOpt{}, R} (Val:SortSourceaddrCellOpt{}, LblnoSourceaddrCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortStackCellOpt{}, \equals{SortStackCellOpt{}, R} (Val:SortStackCellOpt{}, LblnoStackCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortStoragetypeCellOpt{}, \equals{SortStoragetypeCellOpt{}, R} (Val:SortStoragetypeCellOpt{}, LblnoStoragetypeCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortStoragevalueCellOpt{}, \equals{SortStoragevalueCellOpt{}, R} (Val:SortStoragevalueCellOpt{}, LblnoStoragevalueCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortSymbolsCellOpt{}, \equals{SortSymbolsCellOpt{}, R} (Val:SortSymbolsCellOpt{}, LblnoSymbolsCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortTraceCellOpt{}, \equals{SortTraceCellOpt{}, R} (Val:SortTraceCellOpt{}, LblnoTraceCell{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBool{}, \equals{SortBool{}, R} (Val:SortBool{}, LblnotBool'Unds'{}(K0:SortBool{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortNowGroup{}, \equals{SortNowGroup{}, R} (Val:SortNowGroup{}, Lblnow'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'NowGroup'Unds'Int{}(K0:SortInt{}))) [functional{}()] // functional + axiom{}\implies{SortNowGroup{}} (\and{SortNowGroup{}} (Lblnow'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'NowGroup'Unds'Int{}(X0:SortInt{}), Lblnow'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'NowGroup'Unds'Int{}(Y0:SortInt{})), Lblnow'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'NowGroup'Unds'Int{}(\and{SortInt{}} (X0:SortInt{}, Y0:SortInt{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortNullaryTypeName{}, \equals{SortNullaryTypeName{}, R} (Val:SortNullaryTypeName{}, Lbloperation'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [functional{}()] // functional + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lbloperation'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblsignature'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lbloperation'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblstring'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lbloperation'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lbltimestamp'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lbloperation'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblunit'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortUnaryTypeName{}, \equals{SortUnaryTypeName{}, R} (Val:SortUnaryTypeName{}, Lbloption'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}())) [functional{}()] // functional + axiom{}\not{SortUnaryTypeName{}} (\and{SortUnaryTypeName{}} (Lbloption'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(), Lblset'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortBinaryTypeName{}, \equals{SortBinaryTypeName{}, R} (Val:SortBinaryTypeName{}, Lblor'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}())) [functional{}()] // functional + axiom{}\not{SortBinaryTypeName{}} (\and{SortBinaryTypeName{}} (Lblor'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}(), Lblpair'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortContractsGroup{}, \equals{SortContractsGroup{}, R} (Val:SortContractsGroup{}, Lblother'Unds'contracts'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'ContractsGroup'Unds'OtherContractsMapEntryList{}(K0:SortOtherContractsMapEntryList{}))) [functional{}()] // functional + axiom{}\implies{SortContractsGroup{}} (\and{SortContractsGroup{}} (Lblother'Unds'contracts'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'ContractsGroup'Unds'OtherContractsMapEntryList{}(X0:SortOtherContractsMapEntryList{}), Lblother'Unds'contracts'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'ContractsGroup'Unds'OtherContractsMapEntryList{}(Y0:SortOtherContractsMapEntryList{})), Lblother'Unds'contracts'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'ContractsGroup'Unds'OtherContractsMapEntryList{}(\and{SortOtherContractsMapEntryList{}} (X0:SortOtherContractsMapEntryList{}, Y0:SortOtherContractsMapEntryList{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortOutputGroup{}, \equals{SortOutputGroup{}, R} (Val:SortOutputGroup{}, Lbloutput'UndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'OutputGroup'Unds'OutputStack{}(K0:SortOutputStack{}))) [functional{}()] // functional + axiom{}\implies{SortOutputGroup{}} (\and{SortOutputGroup{}} (Lbloutput'UndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'OutputGroup'Unds'OutputStack{}(X0:SortOutputStack{}), Lbloutput'UndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'OutputGroup'Unds'OutputStack{}(Y0:SortOutputStack{})), Lbloutput'UndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'OutputGroup'Unds'OutputStack{}(\and{SortOutputStack{}} (X0:SortOutputStack{}, Y0:SortOutputStack{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortBinaryTypeName{}, \equals{SortBinaryTypeName{}, R} (Val:SortBinaryTypeName{}, Lblpair'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortParameterDecl{}, \equals{SortParameterDecl{}, R} (Val:SortParameterDecl{}, Lblparameter'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'ParameterDecl'Unds'Type{}(K0:SortType{}))) [functional{}()] // functional + axiom{}\implies{SortParameterDecl{}} (\and{SortParameterDecl{}} (Lblparameter'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'ParameterDecl'Unds'Type{}(X0:SortType{}), Lblparameter'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'ParameterDecl'Unds'Type{}(Y0:SortType{})), Lblparameter'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'ParameterDecl'Unds'Type{}(\and{SortType{}} (X0:SortType{}, Y0:SortType{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortParameterValueGroup{}, \equals{SortParameterValueGroup{}, R} (Val:SortParameterValueGroup{}, Lblparameter'Unds'value'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'ParameterValueGroup'Unds'Data{}(K0:SortData{}))) [functional{}()] // functional + axiom{}\implies{SortParameterValueGroup{}} (\and{SortParameterValueGroup{}} (Lblparameter'Unds'value'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'ParameterValueGroup'Unds'Data{}(X0:SortData{}), Lblparameter'Unds'value'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'ParameterValueGroup'Unds'Data{}(Y0:SortData{})), Lblparameter'Unds'value'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'ParameterValueGroup'Unds'Data{}(\and{SortData{}} (X0:SortData{}, Y0:SortData{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortPostconditionGroup{}, \equals{SortPostconditionGroup{}, R} (Val:SortPostconditionGroup{}, Lblpostcondition'LBraUndsRBraUnds'SYMBOLIC-UNIT-TEST-COMMON-SYNTAX'Unds'PostconditionGroup'Unds'BlockList{}(K0:SortBlockList{}))) [functional{}()] // functional + axiom{}\implies{SortPostconditionGroup{}} (\and{SortPostconditionGroup{}} (Lblpostcondition'LBraUndsRBraUnds'SYMBOLIC-UNIT-TEST-COMMON-SYNTAX'Unds'PostconditionGroup'Unds'BlockList{}(X0:SortBlockList{}), Lblpostcondition'LBraUndsRBraUnds'SYMBOLIC-UNIT-TEST-COMMON-SYNTAX'Unds'PostconditionGroup'Unds'BlockList{}(Y0:SortBlockList{})), Lblpostcondition'LBraUndsRBraUnds'SYMBOLIC-UNIT-TEST-COMMON-SYNTAX'Unds'PostconditionGroup'Unds'BlockList{}(\and{SortBlockList{}} (X0:SortBlockList{}, Y0:SortBlockList{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortPreconditionGroup{}, \equals{SortPreconditionGroup{}, R} (Val:SortPreconditionGroup{}, Lblprecondition'LBraUndsRBraUnds'SYMBOLIC-UNIT-TEST-COMMON-SYNTAX'Unds'PreconditionGroup'Unds'BlockList{}(K0:SortBlockList{}))) [functional{}()] // functional + axiom{}\implies{SortPreconditionGroup{}} (\and{SortPreconditionGroup{}} (Lblprecondition'LBraUndsRBraUnds'SYMBOLIC-UNIT-TEST-COMMON-SYNTAX'Unds'PreconditionGroup'Unds'BlockList{}(X0:SortBlockList{}), Lblprecondition'LBraUndsRBraUnds'SYMBOLIC-UNIT-TEST-COMMON-SYNTAX'Unds'PreconditionGroup'Unds'BlockList{}(Y0:SortBlockList{})), Lblprecondition'LBraUndsRBraUnds'SYMBOLIC-UNIT-TEST-COMMON-SYNTAX'Unds'PreconditionGroup'Unds'BlockList{}(\and{SortBlockList{}} (X0:SortBlockList{}, Y0:SortBlockList{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortMap{}, \equals{SortMap{}, R} (Val:SortMap{}, LblremoveAll'LParUndsCommUndsRParUnds'MAP'Unds'Map'Unds'Map'Unds'Set{}(K0:SortMap{}, K1:SortSet{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortString{}, \equals{SortString{}, R} (Val:SortString{}, LblreplaceAll'LParUndsCommUndsCommUndsRParUnds'STRING-COMMON'Unds'String'Unds'String'Unds'String'Unds'String{}(K0:SortString{}, K1:SortString{}, K2:SortString{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortString{}, \equals{SortString{}, R} (Val:SortString{}, LblreplaceFirst'LParUndsCommUndsCommUndsRParUnds'STRING-COMMON'Unds'String'Unds'String'Unds'String'Unds'String{}(K0:SortString{}, K1:SortString{}, K2:SortString{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBytes{}, \equals{SortBytes{}, R} (Val:SortBytes{}, LblreverseBytes'LParUndsRParUnds'BYTES-HOOKED'Unds'Bytes'Unds'Bytes{}(K0:SortBytes{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortSelfGroup{}, \equals{SortSelfGroup{}, R} (Val:SortSelfGroup{}, Lblself'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'SelfGroup'Unds'String{}(K0:SortString{}))) [functional{}()] // functional + axiom{}\implies{SortSelfGroup{}} (\and{SortSelfGroup{}} (Lblself'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'SelfGroup'Unds'String{}(X0:SortString{}), Lblself'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'SelfGroup'Unds'String{}(Y0:SortString{})), Lblself'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'SelfGroup'Unds'String{}(\and{SortString{}} (X0:SortString{}, Y0:SortString{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortSenderGroup{}, \equals{SortSenderGroup{}, R} (Val:SortSenderGroup{}, Lblsender'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'SenderGroup'Unds'String{}(K0:SortString{}))) [functional{}()] // functional + axiom{}\implies{SortSenderGroup{}} (\and{SortSenderGroup{}} (Lblsender'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'SenderGroup'Unds'String{}(X0:SortString{}), Lblsender'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'SenderGroup'Unds'String{}(Y0:SortString{})), Lblsender'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'SenderGroup'Unds'String{}(\and{SortString{}} (X0:SortString{}, Y0:SortString{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortUnaryTypeName{}, \equals{SortUnaryTypeName{}, R} (Val:SortUnaryTypeName{}, Lblset'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortNullaryTypeName{}, \equals{SortNullaryTypeName{}, R} (Val:SortNullaryTypeName{}, Lblsignature'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [functional{}()] // functional + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblsignature'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblstring'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblsignature'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lbltimestamp'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblsignature'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblunit'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortSignedness{}, \equals{SortSignedness{}, R} (Val:SortSignedness{}, LblsignedBytes{}())) [functional{}()] // functional + axiom{}\not{SortSignedness{}} (\and{SortSignedness{}} (LblsignedBytes{}(), LblunsignedBytes{}())) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortInt{}, \equals{SortInt{}, R} (Val:SortInt{}, Lblsize'LParUndsRParUnds'LIST'Unds'Int'Unds'List{}(K0:SortList{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInt{}, \equals{SortInt{}, R} (Val:SortInt{}, Lblsize'LParUndsRParUnds'MAP'Unds'Int'Unds'Map{}(K0:SortMap{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInt{}, \equals{SortInt{}, R} (Val:SortInt{}, Lblsize'LParUndsRParUnds'SET'Unds'Int'Unds'Set{}(K0:SortSet{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortSourceGroup{}, \equals{SortSourceGroup{}, R} (Val:SortSourceGroup{}, Lblsource'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'SourceGroup'Unds'String{}(K0:SortString{}))) [functional{}()] // functional + axiom{}\implies{SortSourceGroup{}} (\and{SortSourceGroup{}} (Lblsource'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'SourceGroup'Unds'String{}(X0:SortString{}), Lblsource'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'SourceGroup'Unds'String{}(Y0:SortString{})), Lblsource'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'SourceGroup'Unds'String{}(\and{SortString{}} (X0:SortString{}, Y0:SortString{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortStorageDecl{}, \equals{SortStorageDecl{}, R} (Val:SortStorageDecl{}, Lblstorage'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'StorageDecl'Unds'Type{}(K0:SortType{}))) [functional{}()] // functional + axiom{}\implies{SortStorageDecl{}} (\and{SortStorageDecl{}} (Lblstorage'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'StorageDecl'Unds'Type{}(X0:SortType{}), Lblstorage'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'StorageDecl'Unds'Type{}(Y0:SortType{})), Lblstorage'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'StorageDecl'Unds'Type{}(\and{SortType{}} (X0:SortType{}, Y0:SortType{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortStorageValueGroup{}, \equals{SortStorageValueGroup{}, R} (Val:SortStorageValueGroup{}, Lblstorage'Unds'value'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'StorageValueGroup'Unds'Data{}(K0:SortData{}))) [functional{}()] // functional + axiom{}\implies{SortStorageValueGroup{}} (\and{SortStorageValueGroup{}} (Lblstorage'Unds'value'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'StorageValueGroup'Unds'Data{}(X0:SortData{}), Lblstorage'Unds'value'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'StorageValueGroup'Unds'Data{}(Y0:SortData{})), Lblstorage'Unds'value'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'StorageValueGroup'Unds'Data{}(\and{SortData{}} (X0:SortData{}, Y0:SortData{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortNullaryTypeName{}, \equals{SortNullaryTypeName{}, R} (Val:SortNullaryTypeName{}, Lblstring'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [functional{}()] // functional + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblstring'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lbltimestamp'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lblstring'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblunit'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortString{}, \equals{SortString{}, R} (Val:SortString{}, LblsubstrString'LParUndsCommUndsCommUndsRParUnds'STRING-COMMON'Unds'String'Unds'String'Unds'Int'Unds'Int{}(K0:SortString{}, K1:SortInt{}, K2:SortInt{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortNullaryTypeName{}, \equals{SortNullaryTypeName{}, R} (Val:SortNullaryTypeName{}, Lbltimestamp'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [functional{}()] // functional + axiom{}\not{SortNullaryTypeName{}} (\and{SortNullaryTypeName{}} (Lbltimestamp'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), Lblunit'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [constructor{}()] // no confusion different constructors + axiom{R} \exists{R} (Val:SortNullaryTypeName{}, \equals{SortNullaryTypeName{}, R} (Val:SortNullaryTypeName{}, Lblunit'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortSignedness{}, \equals{SortSignedness{}, R} (Val:SortSignedness{}, LblunsignedBytes{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortMap{}, \equals{SortMap{}, R} (Val:SortMap{}, LblupdateMap'LParUndsCommUndsRParUnds'MAP'Unds'Map'Unds'Map'Unds'Map{}(K0:SortMap{}, K1:SortMap{}))) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortBlock{}, \equals{SortBlock{}, R} (Val:SortBlock{}, Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Block'Unds'DataList{}(K0:SortDataList{}))) [functional{}()] // functional + axiom{}\implies{SortBlock{}} (\and{SortBlock{}} (Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Block'Unds'DataList{}(X0:SortDataList{}), Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Block'Unds'DataList{}(Y0:SortDataList{})), Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Block'Unds'DataList{}(\and{SortDataList{}} (X0:SortDataList{}, Y0:SortDataList{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortMapLiteral{}, \equals{SortMapLiteral{}, R} (Val:SortMapLiteral{}, Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'MapLiteral'Unds'MapEntryList{}(K0:SortMapEntryList{}))) [functional{}()] // functional + axiom{}\implies{SortMapLiteral{}} (\and{SortMapLiteral{}} (Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'MapLiteral'Unds'MapEntryList{}(X0:SortMapEntryList{}), Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'MapLiteral'Unds'MapEntryList{}(Y0:SortMapEntryList{})), Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'MapLiteral'Unds'MapEntryList{}(\and{SortMapEntryList{}} (X0:SortMapEntryList{}, Y0:SortMapEntryList{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortLiteralStack{}, \equals{SortLiteralStack{}, R} (Val:SortLiteralStack{}, Lbl'LBraUndsRBraUnds'UNIT-TEST-COMMON-SYNTAX'Unds'LiteralStack'Unds'StackElementList{}(K0:SortStackElementList{}))) [functional{}()] // functional + axiom{}\implies{SortLiteralStack{}} (\and{SortLiteralStack{}} (Lbl'LBraUndsRBraUnds'UNIT-TEST-COMMON-SYNTAX'Unds'LiteralStack'Unds'StackElementList{}(X0:SortStackElementList{}), Lbl'LBraUndsRBraUnds'UNIT-TEST-COMMON-SYNTAX'Unds'LiteralStack'Unds'StackElementList{}(Y0:SortStackElementList{})), Lbl'LBraUndsRBraUnds'UNIT-TEST-COMMON-SYNTAX'Unds'LiteralStack'Unds'StackElementList{}(\and{SortStackElementList{}} (X0:SortStackElementList{}, Y0:SortStackElementList{}))) [constructor{}()] // no confusion same constructor + axiom{R} \exists{R} (Val:SortEmptyBlock{}, \equals{SortEmptyBlock{}, R} (Val:SortEmptyBlock{}, Lbl'LBraRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'EmptyBlock{}())) [functional{}()] // functional + axiom{R} \exists{R} (Val:SortInt{}, \equals{SortInt{}, R} (Val:SortInt{}, Lbl'Tild'Int'Unds'{}(K0:SortInt{}))) [functional{}()] // functional + axiom{} \or{SortTypeAnnotation{}} (\top{SortTypeAnnotation{}}(), \bottom{SortTypeAnnotation{}}()) [constructor{}()] // no junk (TODO: fix bug with \dv) + axiom{} \or{SortInstruction{}} (Lbl'Hash'AssertTrue'Unds'MICHELSON'Unds'Instruction{}(), \or{SortInstruction{}} (Lbl'Hash'AssumeTrue'Unds'MICHELSON'Unds'Instruction{}(), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortMapOpInfo{}, Lbl'Hash'DoMap'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'MapOpInfo{}(X0:SortMapOpInfo{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortTypeName{}, \exists{SortInstruction{}} (X1:SortMaybeTypeName{}, \exists{SortInstruction{}} (X2:SortList{}, \exists{SortInstruction{}} (X3:SortList{}, \exists{SortInstruction{}} (X4:SortBlock{}, Lbl'Hash'DoMap'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{})))))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortData{}, \exists{SortInstruction{}} (X1:SortMapOpInfo{}, Lbl'Hash'DoMapAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Data'Unds'MapOpInfo{}(X0:SortData{}, X1:SortMapOpInfo{}))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortTypeName{}, \exists{SortInstruction{}} (X1:SortMaybeTypeName{}, \exists{SortInstruction{}} (X2:SortList{}, \exists{SortInstruction{}} (X3:SortList{}, \exists{SortInstruction{}} (X4:SortBlock{}, Lbl'Hash'DoMapAux'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'MaybeTypeName'Unds'List'Unds'List'Unds'Block{}(X0:SortTypeName{}, X1:SortMaybeTypeName{}, X2:SortList{}, X3:SortList{}, X4:SortBlock{})))))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, Lbl'Hash'HandleAnnotations'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortTypeName{}, \exists{SortInstruction{}} (X1:SortData{}, Lbl'Hash'Push'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortK{}, Lbl'Hash'RestoreStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortStack{}, Lbl'Hash'ReturnStack'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack{}(X0:SortStack{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortMutez{}, \exists{SortInstruction{}} (X1:SortInt{}, \exists{SortInstruction{}} (X2:SortInt{}, Lbl'Hash'ValidateMutezAndPush'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Mutez'Unds'Int'Unds'Int{}(X0:SortMutez{}, X1:SortInt{}, X2:SortInt{})))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblABS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblADDRESS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblADD'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblAND'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblAPPLY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortBlockList{}, LblASSERT'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortBlockList{}, LblASSUME'LBraUndsRBraUnds'MICHELSON'Unds'Instruction'Unds'BlockList{}(X0:SortBlockList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortOutputStack{}, \exists{SortInstruction{}} (X1:SortBlock{}, LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(X0:SortOutputStack{}, X1:SortBlock{}))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblBLAKE2B'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblCAR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblCAST'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblCDR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblCHECK'Unds'SIGNATURE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblCOMPARE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblCONCAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblCONS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, \exists{SortInstruction{}} (X1:SortType{}, LblCONTRACT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblCREATE'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, \exists{SortInstruction{}} (X1:SortContract{}, LblCREATE'Unds'CONTRACT'UndsLBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Contract{}(X0:SortAnnotationList{}, X1:SortContract{}))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortInt{}, \exists{SortInstruction{}} (X1:SortInvariant{}, LblCUTPOINT'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Invariant{}(X0:SortInt{}, X1:SortInvariant{}))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortInt{}, \exists{SortInstruction{}} (X1:SortStack{}, LblDIG'Unds'DOWN'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack{}(X0:SortInt{}, X1:SortStack{}))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortStack{}, \exists{SortInstruction{}} (X1:SortStackElement{}, LblDIG'Unds'UP'LParUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Stack'Unds'StackElement{}(X0:SortStack{}, X1:SortStackElement{}))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, \exists{SortInstruction{}} (X1:SortInt{}, LblDIG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, \exists{SortInstruction{}} (X1:SortBlock{}, LblDIP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, \exists{SortInstruction{}} (X1:SortInt{}, \exists{SortInstruction{}} (X2:SortBlock{}, LblDIP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int'Unds'Block{}(X0:SortAnnotationList{}, X1:SortInt{}, X2:SortBlock{})))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblDROP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, \exists{SortInstruction{}} (X1:SortInt{}, LblDROP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortInt{}, \exists{SortInstruction{}} (X1:SortStack{}, \exists{SortInstruction{}} (X2:SortStackElement{}, LblDUG'Unds'DOWN'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Instruction'Unds'Int'Unds'Stack'Unds'StackElement{}(X0:SortInt{}, X1:SortStack{}, X2:SortStackElement{})))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortK{}, LblDUG'Unds'UP'LParUndsRParUnds'MICHELSON'Unds'Instruction'Unds'K{}(X0:SortK{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, \exists{SortInstruction{}} (X1:SortInt{}, LblDUG'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Int{}(X0:SortAnnotationList{}, X1:SortInt{}))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblDUP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblEDIV'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, \exists{SortInstruction{}} (X1:SortType{}, \exists{SortInstruction{}} (X2:SortType{}, LblEMPTY'Unds'BIG'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{})))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, \exists{SortInstruction{}} (X1:SortType{}, \exists{SortInstruction{}} (X2:SortType{}, LblEMPTY'Unds'MAP'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{})))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, \exists{SortInstruction{}} (X1:SortType{}, LblEMPTY'Unds'SET'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblEXEC'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblFAILWITH'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblGET'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblGE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblGT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblHASH'Unds'KEY'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, \exists{SortInstruction{}} (X1:SortBlock{}, \exists{SortInstruction{}} (X2:SortBlock{}, LblIF'Unds'CONS'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{})))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, \exists{SortInstruction{}} (X1:SortBlock{}, \exists{SortInstruction{}} (X2:SortBlock{}, LblIF'Unds'LEFT'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{})))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, \exists{SortInstruction{}} (X1:SortBlock{}, \exists{SortInstruction{}} (X2:SortBlock{}, LblIF'Unds'NONE'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{})))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, \exists{SortInstruction{}} (X1:SortBlock{}, \exists{SortInstruction{}} (X2:SortBlock{}, LblIF'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}, X2:SortBlock{})))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblIMPLICIT'Unds'ACCOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblINT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblISNAT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, \exists{SortInstruction{}} (X1:SortBlock{}, LblITER'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, \exists{SortInstruction{}} (X1:SortType{}, \exists{SortInstruction{}} (X2:SortType{}, \exists{SortInstruction{}} (X3:SortBlock{}, LblLAMBDA'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Type'Unds'Block{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortType{}, X3:SortBlock{}))))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, \exists{SortInstruction{}} (X1:SortType{}, LblLEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblLE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, \exists{SortInstruction{}} (X1:SortBlock{}, LblLOOP'Unds'LEFT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, \exists{SortInstruction{}} (X1:SortBlock{}, LblLOOP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblLSL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblLSR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblLT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, \exists{SortInstruction{}} (X1:SortBlock{}, LblMAP'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Block{}(X0:SortAnnotationList{}, X1:SortBlock{}))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblMEM'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblMUL'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblNEG'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblNEQ'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, \exists{SortInstruction{}} (X1:SortType{}, LblNIL'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, \exists{SortInstruction{}} (X1:SortType{}, LblNONE'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblNOT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblPACK'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortString{}, LblPAUSE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{})), \or{SortInstruction{}} (LblPAUSE'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, \exists{SortInstruction{}} (X1:SortType{}, \exists{SortInstruction{}} (X2:SortData{}, LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(X0:SortAnnotationList{}, X1:SortType{}, X2:SortData{})))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblRENAME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, \exists{SortInstruction{}} (X1:SortType{}, LblRIGHT'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblSET'Unds'DELEGATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblSHA256'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblSHA512'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblSIZE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblSLICE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblSOME'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblSTEPS'Unds'TO'Unds'QUOTA'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (LblSTOP'Unds'MICHELSON-COMMON-SYNTAX'Unds'Instruction{}(), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblSUB'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblSWAP'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortString{}, LblTRACE'LParUndsRParUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'String{}(X0:SortString{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblTRANSFER'Unds'TOKENS'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblUNIT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, \exists{SortInstruction{}} (X1:SortType{}, LblUNPACK'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type{}(X0:SortAnnotationList{}, X1:SortType{}))), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblUNPAIR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblUPDATE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (X0:SortAnnotationList{}, LblXOR'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(X0:SortAnnotationList{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (Val:SortEmptyBlock{}, inj{SortEmptyBlock{}, SortInstruction{}} (Val:SortEmptyBlock{})), \or{SortInstruction{}} (\exists{SortInstruction{}} (Val:SortBlock{}, inj{SortBlock{}, SortInstruction{}} (Val:SortBlock{})), \bottom{SortInstruction{}}()))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) [constructor{}()] // no junk + axiom{} \or{SortScriptCellOpt{}} (LblnoScriptCell{}(), \or{SortScriptCellOpt{}} (\exists{SortScriptCellOpt{}} (Val:SortScriptCell{}, inj{SortScriptCell{}, SortScriptCellOpt{}} (Val:SortScriptCell{})), \bottom{SortScriptCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortNonceCellOpt{}} (LblnoNonceCell{}(), \or{SortNonceCellOpt{}} (\exists{SortNonceCellOpt{}} (Val:SortNonceCell{}, inj{SortNonceCell{}, SortNonceCellOpt{}} (Val:SortNonceCell{})), \bottom{SortNonceCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortScriptCell{}} (\exists{SortScriptCell{}} (X0:SortPreData{}, Lbl'-LT-'script'-GT-'{}(X0:SortPreData{})), \bottom{SortScriptCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortMybalanceCell{}} (\exists{SortMybalanceCell{}} (X0:SortMutez{}, Lbl'-LT-'mybalance'-GT-'{}(X0:SortMutez{})), \bottom{SortMybalanceCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortParamtypeCellOpt{}} (LblnoParamtypeCell{}(), \or{SortParamtypeCellOpt{}} (\exists{SortParamtypeCellOpt{}} (Val:SortParamtypeCell{}, inj{SortParamtypeCell{}, SortParamtypeCellOpt{}} (Val:SortParamtypeCell{})), \bottom{SortParamtypeCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortStoragevalueCellOpt{}} (LblnoStoragevalueCell{}(), \or{SortStoragevalueCellOpt{}} (\exists{SortStoragevalueCellOpt{}} (Val:SortStoragevalueCell{}, inj{SortStoragevalueCell{}, SortStoragevalueCellOpt{}} (Val:SortStoragevalueCell{})), \bottom{SortStoragevalueCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortKItem{}} (\exists{SortKItem{}} (X0:SortBoolExp{}, Lbl'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{})), \or{SortKItem{}} (Lbl'Hash'AssertFailed{}(), \or{SortKItem{}} (\exists{SortKItem{}} (X0:SortBoolExp{}, Lbl'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp{}(X0:SortBoolExp{})), \or{SortKItem{}} (\exists{SortKItem{}} (X0:SortSequenceData{}, \exists{SortKItem{}} (X1:SortType{}, Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(X0:SortSequenceData{}, X1:SortType{}))), \or{SortKItem{}} (\exists{SortKItem{}} (X0:SortInternalStack{}, \exists{SortKItem{}} (X1:SortInternalStack{}, Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(X0:SortInternalStack{}, X1:SortInternalStack{}))), \or{SortKItem{}} (Lbl'Hash'ConvertBigMapsToNative'Unds'MICHELSON'Unds'KItem{}(), \or{SortKItem{}} (Lbl'Hash'ConvertParamToNative'Unds'MICHELSON'Unds'KItem{}(), \or{SortKItem{}} (Lbl'Hash'ConvertStorageToNative'Unds'MICHELSON'Unds'KItem{}(), \or{SortKItem{}} (\exists{SortKItem{}} (X0:SortSymbolicData{}, \exists{SortKItem{}} (X1:SortType{}, Lbl'Hash'CreateSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SymbolicData'Unds'Type{}(X0:SortSymbolicData{}, X1:SortType{}))), \or{SortKItem{}} (\exists{SortKItem{}} (X0:SortUnifiedList{}, Lbl'Hash'CreateSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'UnifiedList{}(X0:SortUnifiedList{})), \or{SortKItem{}} (Lbl'Hash'CreateSymbols'Unds'MICHELSON'Unds'KItem{}(), \or{SortKItem{}} (Lbl'Hash'ExecutePostConditions'Unds'MICHELSON'Unds'KItem{}(), \or{SortKItem{}} (Lbl'Hash'ExecutePreConditions'Unds'MICHELSON'Unds'KItem{}(), \or{SortKItem{}} (Lbl'Hash'ExecuteScript'Unds'MICHELSON'Unds'KItem{}(), \or{SortKItem{}} (\exists{SortKItem{}} (X0:SortStackElementList{}, \exists{SortKItem{}} (X1:SortStack{}, Lbl'Hash'GeneralizeStack'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'StackElementList'Unds'Stack{}(X0:SortStackElementList{}, X1:SortStack{}))), \or{SortKItem{}} (Lbl'Hash'Init'Unds'MICHELSON-CONFIG'Unds'KItem{}(), \or{SortKItem{}} (Lbl'Hash'LoadDefaultContractStack'Unds'MICHELSON'Unds'KItem{}(), \or{SortKItem{}} (Lbl'Hash'LoadInputStack'Unds'MICHELSON'Unds'KItem{}(), \or{SortKItem{}} (\exists{SortKItem{}} (X0:SortMap{}, Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(X0:SortMap{})), \or{SortKItem{}} (Lbl'Hash'freezer'Hash'Assert'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}(), \or{SortKItem{}} (Lbl'Hash'freezer'Hash'Assume'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'BoolExp0'Unds'{}(), \or{SortKItem{}} (\exists{SortKItem{}} (X0:SortInt{}, \exists{SortKItem{}} (X1:SortString{}, \exists{SortKItem{}} (X2:SortString{}, Lbl'Hash'systemResult{}(X0:SortInt{}, X1:SortString{}, X2:SortString{})))), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortTypeAnnotation{}, inj{SortTypeAnnotation{}, SortKItem{}} (Val:SortTypeAnnotation{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortInstruction{}, inj{SortInstruction{}, SortKItem{}} (Val:SortInstruction{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortScriptCellOpt{}, inj{SortScriptCellOpt{}, SortKItem{}} (Val:SortScriptCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortNonceCellOpt{}, inj{SortNonceCellOpt{}, SortKItem{}} (Val:SortNonceCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortScriptCell{}, inj{SortScriptCell{}, SortKItem{}} (Val:SortScriptCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortMybalanceCell{}, inj{SortMybalanceCell{}, SortKItem{}} (Val:SortMybalanceCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortParamtypeCellOpt{}, inj{SortParamtypeCellOpt{}, SortKItem{}} (Val:SortParamtypeCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortStoragevalueCellOpt{}, inj{SortStoragevalueCellOpt{}, SortKItem{}} (Val:SortStoragevalueCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortMapLiteral{}, inj{SortMapLiteral{}, SortKItem{}} (Val:SortMapLiteral{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortExpectedCell{}, inj{SortExpectedCell{}, SortKItem{}} (Val:SortExpectedCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortMychainidCell{}, inj{SortMychainidCell{}, SortKItem{}} (Val:SortMychainidCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortStack{}, inj{SortStack{}, SortKItem{}} (Val:SortStack{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortSourceGroup{}, inj{SortSourceGroup{}, SortKItem{}} (Val:SortSourceGroup{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortData{}, inj{SortData{}, SortKItem{}} (Val:SortData{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortList{}, inj{SortList{}, SortKItem{}} (Val:SortList{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortMBytesLiteral{}, inj{SortMBytesLiteral{}, SortKItem{}} (Val:SortMBytesLiteral{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortTraceCellOpt{}, inj{SortTraceCellOpt{}, SortKItem{}} (Val:SortTraceCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortPreCell{}, inj{SortPreCell{}, SortKItem{}} (Val:SortPreCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortKey{}, inj{SortKey{}, SortKItem{}} (Val:SortKey{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortStoragetypeCell{}, inj{SortStoragetypeCell{}, SortKItem{}} (Val:SortStoragetypeCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortInputGroup{}, inj{SortInputGroup{}, SortKItem{}} (Val:SortInputGroup{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortStackElementLiteral{}, inj{SortStackElementLiteral{}, SortKItem{}} (Val:SortStackElementLiteral{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortTypedData{}, inj{SortTypedData{}, SortKItem{}} (Val:SortTypedData{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortMyaddrCell{}, inj{SortMyaddrCell{}, SortKItem{}} (Val:SortMyaddrCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortString{}, inj{SortString{}, SortKItem{}} (Val:SortString{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortTypeName{}, inj{SortTypeName{}, SortKItem{}} (Val:SortTypeName{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortTypedSymbol{}, inj{SortTypedSymbol{}, SortKItem{}} (Val:SortTypedSymbol{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortSymbolicElement{}, inj{SortSymbolicElement{}, SortKItem{}} (Val:SortSymbolicElement{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortTimestamp{}, inj{SortTimestamp{}, SortKItem{}} (Val:SortTimestamp{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortMichelsonBool{}, inj{SortMichelsonBool{}, SortKItem{}} (Val:SortMichelsonBool{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortKeyHash{}, inj{SortKeyHash{}, SortKItem{}} (Val:SortKeyHash{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortIOInt{}, inj{SortIOInt{}, SortKItem{}} (Val:SortIOInt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortPreType{}, inj{SortPreType{}, SortKItem{}} (Val:SortPreType{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortMyamountCellOpt{}, inj{SortMyamountCellOpt{}, SortKItem{}} (Val:SortMyamountCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortCutpointsCell{}, inj{SortCutpointsCell{}, SortKItem{}} (Val:SortCutpointsCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortMybalanceCellOpt{}, inj{SortMybalanceCellOpt{}, SortKItem{}} (Val:SortMybalanceCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortBlockchainOperation{}, inj{SortBlockchainOperation{}, SortKItem{}} (Val:SortBlockchainOperation{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortExpectedCellOpt{}, inj{SortExpectedCellOpt{}, SortKItem{}} (Val:SortExpectedCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortBigMapGroup{}, inj{SortBigMapGroup{}, SortKItem{}} (Val:SortBigMapGroup{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortContractData{}, inj{SortContractData{}, SortKItem{}} (Val:SortContractData{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortKnownaddrsCell{}, inj{SortKnownaddrsCell{}, SortKItem{}} (Val:SortKnownaddrsCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortError{}, inj{SortError{}, SortKItem{}} (Val:SortError{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortSimpleData{}, inj{SortSimpleData{}, SortKItem{}} (Val:SortSimpleData{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortParamvalueCell{}, inj{SortParamvalueCell{}, SortKItem{}} (Val:SortParamvalueCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortMutez{}, inj{SortMutez{}, SortKItem{}} (Val:SortMutez{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortBoolExp{}, inj{SortBoolExp{}, SortKItem{}} (Val:SortBoolExp{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortStackCellOpt{}, inj{SortStackCellOpt{}, SortKItem{}} (Val:SortStackCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortPreData{}, inj{SortPreData{}, SortKItem{}} (Val:SortPreData{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortSymbolsCell{}, inj{SortSymbolsCell{}, SortKItem{}} (Val:SortSymbolsCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortGeneratedCounterCellOpt{}, inj{SortGeneratedCounterCellOpt{}, SortKItem{}} (Val:SortGeneratedCounterCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortBigMapEntry{}, inj{SortBigMapEntry{}, SortKItem{}} (Val:SortBigMapEntry{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortUnifiedList{}, inj{SortUnifiedList{}, SortKItem{}} (Val:SortUnifiedList{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortAddress{}, inj{SortAddress{}, SortKItem{}} (Val:SortAddress{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortSimpleType{}, inj{SortSimpleType{}, SortKItem{}} (Val:SortSimpleType{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortMyamountCell{}, inj{SortMyamountCell{}, SortKItem{}} (Val:SortMyamountCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortParamvalueCellOpt{}, inj{SortParamvalueCellOpt{}, SortKItem{}} (Val:SortParamvalueCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortDataOrSeq{}, inj{SortDataOrSeq{}, SortKItem{}} (Val:SortDataOrSeq{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortCutpointsCellOpt{}, inj{SortCutpointsCellOpt{}, SortKItem{}} (Val:SortCutpointsCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortGeneratedCounterCell{}, inj{SortGeneratedCounterCell{}, SortKItem{}} (Val:SortGeneratedCounterCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortSenderGroup{}, inj{SortSenderGroup{}, SortKItem{}} (Val:SortSenderGroup{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortGroups{}, inj{SortGroups{}, SortKItem{}} (Val:SortGroups{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortSequenceData{}, inj{SortSequenceData{}, SortKItem{}} (Val:SortSequenceData{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortUnaryTypeName{}, inj{SortUnaryTypeName{}, SortKItem{}} (Val:SortUnaryTypeName{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortId{}, inj{SortId{}, SortKItem{}} (Val:SortId{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortSenderaddrCellOpt{}, inj{SortSenderaddrCellOpt{}, SortKItem{}} (Val:SortSenderaddrCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortEmptyBlock{}, inj{SortEmptyBlock{}, SortKItem{}} (Val:SortEmptyBlock{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortSignedness{}, inj{SortSignedness{}, SortKItem{}} (Val:SortSignedness{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortSourceaddrCellOpt{}, inj{SortSourceaddrCellOpt{}, SortKItem{}} (Val:SortSourceaddrCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortSourceaddrCell{}, inj{SortSourceaddrCell{}, SortKItem{}} (Val:SortSourceaddrCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortNullaryTypeName{}, inj{SortNullaryTypeName{}, SortKItem{}} (Val:SortNullaryTypeName{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortStackElementList{}, inj{SortStackElementList{}, SortKItem{}} (Val:SortStackElementList{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortStream{}, inj{SortStream{}, SortKItem{}} (Val:SortStream{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortCell{}, inj{SortCell{}, SortKItem{}} (Val:SortCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortBool{}, inj{SortBool{}, SortKItem{}} (Val:SortBool{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortMynowCell{}, inj{SortMynowCell{}, SortKItem{}} (Val:SortMynowCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortOtherContractsMapEntry{}, inj{SortOtherContractsMapEntry{}, SortKItem{}} (Val:SortOtherContractsMapEntry{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortKCell{}, inj{SortKCell{}, SortKItem{}} (Val:SortKCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortParameterValueGroup{}, inj{SortParameterValueGroup{}, SortKItem{}} (Val:SortParameterValueGroup{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortIOFile{}, inj{SortIOFile{}, SortKItem{}} (Val:SortIOFile{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortPostCell{}, inj{SortPostCell{}, SortKItem{}} (Val:SortPostCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortParameterDecl{}, inj{SortParameterDecl{}, SortKItem{}} (Val:SortParameterDecl{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortOrData{}, inj{SortOrData{}, SortKItem{}} (Val:SortOrData{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortTraceCell{}, inj{SortTraceCell{}, SortKItem{}} (Val:SortTraceCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortOptionData{}, inj{SortOptionData{}, SortKItem{}} (Val:SortOptionData{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortUnificationFailure{}, inj{SortUnificationFailure{}, SortKItem{}} (Val:SortUnificationFailure{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortPreconditionGroup{}, inj{SortPreconditionGroup{}, SortKItem{}} (Val:SortPreconditionGroup{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortMaybeTypeName{}, inj{SortMaybeTypeName{}, SortKItem{}} (Val:SortMaybeTypeName{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortKResult{}, inj{SortKResult{}, SortKItem{}} (Val:SortKResult{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortContract{}, inj{SortContract{}, SortKItem{}} (Val:SortContract{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortBinaryTypeName{}, inj{SortBinaryTypeName{}, SortKItem{}} (Val:SortBinaryTypeName{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortEndianness{}, inj{SortEndianness{}, SortKItem{}} (Val:SortEndianness{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortMichelsonTopCellFragment{}, inj{SortMichelsonTopCellFragment{}, SortKItem{}} (Val:SortMichelsonTopCellFragment{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortNowGroup{}, inj{SortNowGroup{}, SortKItem{}} (Val:SortNowGroup{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortMap{}, inj{SortMap{}, SortKItem{}} (Val:SortMap{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortMichelsonTopCell{}, inj{SortMichelsonTopCell{}, SortKItem{}} (Val:SortMichelsonTopCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortMapEntryList{}, inj{SortMapEntryList{}, SortKItem{}} (Val:SortMapEntryList{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortReturncodeCell{}, inj{SortReturncodeCell{}, SortKItem{}} (Val:SortReturncodeCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortMyaddrCellOpt{}, inj{SortMyaddrCellOpt{}, SortKItem{}} (Val:SortMyaddrCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortMapEntry{}, inj{SortMapEntry{}, SortKItem{}} (Val:SortMapEntry{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortInvariant{}, inj{SortInvariant{}, SortKItem{}} (Val:SortInvariant{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortStorageValueGroup{}, inj{SortStorageValueGroup{}, SortKItem{}} (Val:SortStorageValueGroup{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortAnnotationList{}, inj{SortAnnotationList{}, SortKItem{}} (Val:SortAnnotationList{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortStackElement{}, inj{SortStackElement{}, SortKItem{}} (Val:SortStackElement{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortInvariantsGroup{}, inj{SortInvariantsGroup{}, SortKItem{}} (Val:SortInvariantsGroup{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortDataList{}, inj{SortDataList{}, SortKItem{}} (Val:SortDataList{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortLiteralStack{}, inj{SortLiteralStack{}, SortKItem{}} (Val:SortLiteralStack{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortOperationNonce{}, inj{SortOperationNonce{}, SortKItem{}} (Val:SortOperationNonce{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortStackCell{}, inj{SortStackCell{}, SortKItem{}} (Val:SortStackCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortAnnotation{}, inj{SortAnnotation{}, SortKItem{}} (Val:SortAnnotation{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortSelfGroup{}, inj{SortSelfGroup{}, SortKItem{}} (Val:SortSelfGroup{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortUnifiedSet{}, inj{SortUnifiedSet{}, SortKItem{}} (Val:SortUnifiedSet{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortMichelsonTopCellOpt{}, inj{SortMichelsonTopCellOpt{}, SortKItem{}} (Val:SortMichelsonTopCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortKCellOpt{}, inj{SortKCellOpt{}, SortKItem{}} (Val:SortKCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortStorageDecl{}, inj{SortStorageDecl{}, SortKItem{}} (Val:SortStorageDecl{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortGroup{}, inj{SortGroup{}, SortKItem{}} (Val:SortGroup{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortInvsCellOpt{}, inj{SortInvsCellOpt{}, SortKItem{}} (Val:SortInvsCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortOtherContractsMapEntryList{}, inj{SortOtherContractsMapEntryList{}, SortKItem{}} (Val:SortOtherContractsMapEntryList{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortStoragetypeCellOpt{}, inj{SortStoragetypeCellOpt{}, SortKItem{}} (Val:SortStoragetypeCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortParameterGroup{}, inj{SortParameterGroup{}, SortKItem{}} (Val:SortParameterGroup{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortInt{}, inj{SortInt{}, SortKItem{}} (Val:SortInt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortPair{}, inj{SortPair{}, SortKItem{}} (Val:SortPair{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortBigMapEntryList{}, inj{SortBigMapEntryList{}, SortKItem{}} (Val:SortBigMapEntryList{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortOutputGroup{}, inj{SortOutputGroup{}, SortKItem{}} (Val:SortOutputGroup{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortSignature{}, inj{SortSignature{}, SortKItem{}} (Val:SortSignature{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortFloat{}, inj{SortFloat{}, SortKItem{}} (Val:SortFloat{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortBigmapsCellOpt{}, inj{SortBigmapsCellOpt{}, SortKItem{}} (Val:SortBigmapsCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortInputstackCell{}, inj{SortInputstackCell{}, SortKItem{}} (Val:SortInputstackCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortCodeDecl{}, inj{SortCodeDecl{}, SortKItem{}} (Val:SortCodeDecl{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortPreCellOpt{}, inj{SortPreCellOpt{}, SortKItem{}} (Val:SortPreCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortLambdaData{}, inj{SortLambdaData{}, SortKItem{}} (Val:SortLambdaData{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortBalanceGroup{}, inj{SortBalanceGroup{}, SortKItem{}} (Val:SortBalanceGroup{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortInputstackCellOpt{}, inj{SortInputstackCellOpt{}, SortKItem{}} (Val:SortInputstackCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortType{}, inj{SortType{}, SortKItem{}} (Val:SortType{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortNumTypeName{}, inj{SortNumTypeName{}, SortKItem{}} (Val:SortNumTypeName{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortGeneratedTopCell{}, inj{SortGeneratedTopCell{}, SortKItem{}} (Val:SortGeneratedTopCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortPgm{}, inj{SortPgm{}, SortKItem{}} (Val:SortPgm{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortMynowCellOpt{}, inj{SortMynowCellOpt{}, SortKItem{}} (Val:SortMynowCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortBlock{}, inj{SortBlock{}, SortKItem{}} (Val:SortBlock{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortChainGroup{}, inj{SortChainGroup{}, SortKItem{}} (Val:SortChainGroup{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortBigmapsCell{}, inj{SortBigmapsCell{}, SortKItem{}} (Val:SortBigmapsCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortInvsCell{}, inj{SortInvsCell{}, SortKItem{}} (Val:SortInvsCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortKnownaddrsCellOpt{}, inj{SortKnownaddrsCellOpt{}, SortKItem{}} (Val:SortKnownaddrsCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortMychainidCellOpt{}, inj{SortMychainidCellOpt{}, SortKItem{}} (Val:SortMychainidCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortMapOpInfo{}, inj{SortMapOpInfo{}, SortKItem{}} (Val:SortMapOpInfo{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortAssumeFailedCellOpt{}, inj{SortAssumeFailedCellOpt{}, SortKItem{}} (Val:SortAssumeFailedCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortSet{}, inj{SortSet{}, SortKItem{}} (Val:SortSet{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortInternalStack{}, inj{SortInternalStack{}, SortKItem{}} (Val:SortInternalStack{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortChainId{}, inj{SortChainId{}, SortKItem{}} (Val:SortChainId{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortContractGroup{}, inj{SortContractGroup{}, SortKItem{}} (Val:SortContractGroup{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortNonceCell{}, inj{SortNonceCell{}, SortKItem{}} (Val:SortNonceCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortMBytes{}, inj{SortMBytes{}, SortKItem{}} (Val:SortMBytes{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortOutputStack{}, inj{SortOutputStack{}, SortKItem{}} (Val:SortOutputStack{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortFieldAnnotation{}, inj{SortFieldAnnotation{}, SortKItem{}} (Val:SortFieldAnnotation{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortContractsGroup{}, inj{SortContractsGroup{}, SortKItem{}} (Val:SortContractsGroup{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortIOString{}, inj{SortIOString{}, SortKItem{}} (Val:SortIOString{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortStoragevalueCell{}, inj{SortStoragevalueCell{}, SortKItem{}} (Val:SortStoragevalueCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortSymbolicData{}, inj{SortSymbolicData{}, SortKItem{}} (Val:SortSymbolicData{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortParamtypeCell{}, inj{SortParamtypeCell{}, SortKItem{}} (Val:SortParamtypeCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortSymbolsCellOpt{}, inj{SortSymbolsCellOpt{}, SortKItem{}} (Val:SortSymbolsCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortVariableAnnotation{}, inj{SortVariableAnnotation{}, SortKItem{}} (Val:SortVariableAnnotation{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortGeneratedTopCellFragment{}, inj{SortGeneratedTopCellFragment{}, SortKItem{}} (Val:SortGeneratedTopCellFragment{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortMapTypeName{}, inj{SortMapTypeName{}, SortKItem{}} (Val:SortMapTypeName{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortBlockList{}, inj{SortBlockList{}, SortKItem{}} (Val:SortBlockList{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortReturncodeCellOpt{}, inj{SortReturncodeCellOpt{}, SortKItem{}} (Val:SortReturncodeCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortIOError{}, inj{SortIOError{}, SortKItem{}} (Val:SortIOError{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortBytes{}, inj{SortBytes{}, SortKItem{}} (Val:SortBytes{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortAssumeFailedCell{}, inj{SortAssumeFailedCell{}, SortKItem{}} (Val:SortAssumeFailedCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortSenderaddrCell{}, inj{SortSenderaddrCell{}, SortKItem{}} (Val:SortSenderaddrCell{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortAmountGroup{}, inj{SortAmountGroup{}, SortKItem{}} (Val:SortAmountGroup{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortPostconditionGroup{}, inj{SortPostconditionGroup{}, SortKItem{}} (Val:SortPostconditionGroup{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortFailedStack{}, inj{SortFailedStack{}, SortKItem{}} (Val:SortFailedStack{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortPostCellOpt{}, inj{SortPostCellOpt{}, SortKItem{}} (Val:SortPostCellOpt{})), \or{SortKItem{}} (\exists{SortKItem{}} (Val:SortCodeGroup{}, inj{SortCodeGroup{}, SortKItem{}} (Val:SortCodeGroup{})), \bottom{SortKItem{}}()))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) [constructor{}()] // no junk + axiom{} \or{SortMapLiteral{}} (\exists{SortMapLiteral{}} (X0:SortMapEntryList{}, Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'MapLiteral'Unds'MapEntryList{}(X0:SortMapEntryList{})), \bottom{SortMapLiteral{}}()) [constructor{}()] // no junk + axiom{} \or{SortExpectedCell{}} (\exists{SortExpectedCell{}} (X0:SortK{}, Lbl'-LT-'expected'-GT-'{}(X0:SortK{})), \bottom{SortExpectedCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortMychainidCell{}} (\exists{SortMychainidCell{}} (X0:SortChainId{}, Lbl'-LT-'mychainid'-GT-'{}(X0:SortChainId{})), \bottom{SortMychainidCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortStack{}} (Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack'QuotRBraUnds'Stack{}(), \or{SortStack{}} (\exists{SortStack{}} (X0:SortStackElement{}, \exists{SortStack{}} (X1:SortStack{}, Lbl'UndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack{}(X0:SortStackElement{}, X1:SortStack{}))), \bottom{SortStack{}}())) [constructor{}()] // no junk + axiom{} \or{SortSourceGroup{}} (\exists{SortSourceGroup{}} (X0:SortString{}, Lblsource'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'SourceGroup'Unds'String{}(X0:SortString{})), \bottom{SortSourceGroup{}}()) [constructor{}()] // no junk + axiom{} \or{SortData{}} (Lbl'Hash'Any'Unds'UNIT-TEST-COMMON-SYNTAX'Unds'Data{}(), \or{SortData{}} (\exists{SortData{}} (X0:SortType{}, Lbl'Hash'MakeFresh'LParUndsRParUnds'MICHELSON'Unds'Data'Unds'Type{}(X0:SortType{})), \or{SortData{}} (Lbl'Hash'hole'Unds'MICHELSON'Unds'Data{}(), \or{SortData{}} (\exists{SortData{}} (Val:SortInstruction{}, inj{SortInstruction{}, SortData{}} (Val:SortInstruction{})), \or{SortData{}} (\exists{SortData{}} (Val:SortMapLiteral{}, inj{SortMapLiteral{}, SortData{}} (Val:SortMapLiteral{})), \or{SortData{}} (\exists{SortData{}} (Val:SortList{}, inj{SortList{}, SortData{}} (Val:SortList{})), \or{SortData{}} (\exists{SortData{}} (Val:SortMBytesLiteral{}, inj{SortMBytesLiteral{}, SortData{}} (Val:SortMBytesLiteral{})), \or{SortData{}} (\exists{SortData{}} (Val:SortKey{}, inj{SortKey{}, SortData{}} (Val:SortKey{})), \or{SortData{}} (\exists{SortData{}} (Val:SortTypedData{}, inj{SortTypedData{}, SortData{}} (Val:SortTypedData{})), \or{SortData{}} (\exists{SortData{}} (Val:SortString{}, inj{SortString{}, SortData{}} (Val:SortString{})), \or{SortData{}} (\exists{SortData{}} (Val:SortTimestamp{}, inj{SortTimestamp{}, SortData{}} (Val:SortTimestamp{})), \or{SortData{}} (\exists{SortData{}} (Val:SortKeyHash{}, inj{SortKeyHash{}, SortData{}} (Val:SortKeyHash{})), \or{SortData{}} (\exists{SortData{}} (Val:SortBlockchainOperation{}, inj{SortBlockchainOperation{}, SortData{}} (Val:SortBlockchainOperation{})), \or{SortData{}} (\exists{SortData{}} (Val:SortContractData{}, inj{SortContractData{}, SortData{}} (Val:SortContractData{})), \or{SortData{}} (\exists{SortData{}} (Val:SortSimpleData{}, inj{SortSimpleData{}, SortData{}} (Val:SortSimpleData{})), \or{SortData{}} (\exists{SortData{}} (Val:SortMutez{}, inj{SortMutez{}, SortData{}} (Val:SortMutez{})), \or{SortData{}} (\exists{SortData{}} (Val:SortAddress{}, inj{SortAddress{}, SortData{}} (Val:SortAddress{})), \or{SortData{}} (\exists{SortData{}} (Val:SortSequenceData{}, inj{SortSequenceData{}, SortData{}} (Val:SortSequenceData{})), \or{SortData{}} (\exists{SortData{}} (Val:SortEmptyBlock{}, inj{SortEmptyBlock{}, SortData{}} (Val:SortEmptyBlock{})), \or{SortData{}} (\exists{SortData{}} (Val:SortBool{}, inj{SortBool{}, SortData{}} (Val:SortBool{})), \or{SortData{}} (\exists{SortData{}} (Val:SortOrData{}, inj{SortOrData{}, SortData{}} (Val:SortOrData{})), \or{SortData{}} (\exists{SortData{}} (Val:SortOptionData{}, inj{SortOptionData{}, SortData{}} (Val:SortOptionData{})), \or{SortData{}} (\exists{SortData{}} (Val:SortMap{}, inj{SortMap{}, SortData{}} (Val:SortMap{})), \or{SortData{}} (\exists{SortData{}} (Val:SortInt{}, inj{SortInt{}, SortData{}} (Val:SortInt{})), \or{SortData{}} (\exists{SortData{}} (Val:SortPair{}, inj{SortPair{}, SortData{}} (Val:SortPair{})), \or{SortData{}} (\exists{SortData{}} (Val:SortSignature{}, inj{SortSignature{}, SortData{}} (Val:SortSignature{})), \or{SortData{}} (\exists{SortData{}} (Val:SortLambdaData{}, inj{SortLambdaData{}, SortData{}} (Val:SortLambdaData{})), \or{SortData{}} (\exists{SortData{}} (Val:SortBlock{}, inj{SortBlock{}, SortData{}} (Val:SortBlock{})), \or{SortData{}} (\exists{SortData{}} (Val:SortSet{}, inj{SortSet{}, SortData{}} (Val:SortSet{})), \or{SortData{}} (\exists{SortData{}} (Val:SortChainId{}, inj{SortChainId{}, SortData{}} (Val:SortChainId{})), \or{SortData{}} (\exists{SortData{}} (Val:SortMBytes{}, inj{SortMBytes{}, SortData{}} (Val:SortMBytes{})), \or{SortData{}} (\exists{SortData{}} (Val:SortSymbolicData{}, inj{SortSymbolicData{}, SortData{}} (Val:SortSymbolicData{})), \or{SortData{}} (\exists{SortData{}} (Val:SortBytes{}, inj{SortBytes{}, SortData{}} (Val:SortBytes{})), \or{SortData{}} (\exists{SortData{}} (Val:SortFailedStack{}, inj{SortFailedStack{}, SortData{}} (Val:SortFailedStack{})), \bottom{SortData{}}())))))))))))))))))))))))))))))))))) [constructor{}()] // no junk + axiom{} \bottom{SortList{}}() [constructor{}()] // no junk + axiom{} \or{SortMBytesLiteral{}} (\top{SortMBytesLiteral{}}(), \bottom{SortMBytesLiteral{}}()) [constructor{}()] // no junk (TODO: fix bug with \dv) + axiom{} \or{SortTraceCellOpt{}} (LblnoTraceCell{}(), \or{SortTraceCellOpt{}} (\exists{SortTraceCellOpt{}} (Val:SortTraceCell{}, inj{SortTraceCell{}, SortTraceCellOpt{}} (Val:SortTraceCell{})), \bottom{SortTraceCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortPreCell{}} (\exists{SortPreCell{}} (X0:SortBlockList{}, Lbl'-LT-'pre'-GT-'{}(X0:SortBlockList{})), \bottom{SortPreCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortKey{}} (\exists{SortKey{}} (X0:SortString{}, Lbl'Hash'Key'LParUndsRParUnds'MICHELSON-COMMON'Unds'Key'Unds'String{}(X0:SortString{})), \bottom{SortKey{}}()) [constructor{}()] // no junk + axiom{} \or{SortStoragetypeCell{}} (\exists{SortStoragetypeCell{}} (X0:SortPreType{}, Lbl'-LT-'storagetype'-GT-'{}(X0:SortPreType{})), \bottom{SortStoragetypeCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortInputGroup{}} (\exists{SortInputGroup{}} (X0:SortLiteralStack{}, Lblinput'UndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'InputGroup'Unds'LiteralStack{}(X0:SortLiteralStack{})), \bottom{SortInputGroup{}}()) [constructor{}()] // no junk + axiom{} \or{SortStackElementLiteral{}} (\exists{SortStackElementLiteral{}} (X0:SortType{}, \exists{SortStackElementLiteral{}} (X1:SortData{}, LblStack'Unds'elt'UndsUndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'StackElementLiteral'Unds'Type'Unds'Data{}(X0:SortType{}, X1:SortData{}))), \bottom{SortStackElementLiteral{}}()) [constructor{}()] // no junk + axiom{} \or{SortTypedData{}} (\exists{SortTypedData{}} (X0:SortData{}, \exists{SortTypedData{}} (X1:SortType{}, Lbl'Hash'Typed'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'TypedData'Unds'Data'Unds'Type{}(X0:SortData{}, X1:SortType{}))), \bottom{SortTypedData{}}()) [constructor{}()] // no junk + axiom{} \or{SortMyaddrCell{}} (\exists{SortMyaddrCell{}} (X0:SortAddress{}, Lbl'-LT-'myaddr'-GT-'{}(X0:SortAddress{})), \bottom{SortMyaddrCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortString{}} (\top{SortString{}}(), \bottom{SortString{}}()) [constructor{}()] // no junk (TODO: fix bug with \dv) + axiom{} \or{SortTypeName{}} (\exists{SortTypeName{}} (X0:SortUnaryTypeName{}, \exists{SortTypeName{}} (X1:SortTypeName{}, Lbl'UndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'UnaryTypeName'Unds'TypeName{}(X0:SortUnaryTypeName{}, X1:SortTypeName{}))), \or{SortTypeName{}} (\exists{SortTypeName{}} (X0:SortBinaryTypeName{}, \exists{SortTypeName{}} (X1:SortTypeName{}, \exists{SortTypeName{}} (X2:SortTypeName{}, Lbl'UndsUndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'BinaryTypeName'Unds'TypeName'Unds'TypeName{}(X0:SortBinaryTypeName{}, X1:SortTypeName{}, X2:SortTypeName{})))), \or{SortTypeName{}} (\exists{SortTypeName{}} (Val:SortNullaryTypeName{}, inj{SortNullaryTypeName{}, SortTypeName{}} (Val:SortNullaryTypeName{})), \or{SortTypeName{}} (\exists{SortTypeName{}} (Val:SortNumTypeName{}, inj{SortNumTypeName{}, SortTypeName{}} (Val:SortNumTypeName{})), \bottom{SortTypeName{}}())))) [constructor{}()] // no junk + axiom{} \or{SortTypedSymbol{}} (\exists{SortTypedSymbol{}} (X0:SortTypeName{}, \exists{SortTypedSymbol{}} (X1:SortData{}, Lbl'Hash'TypedSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'TypedSymbol'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}))), \bottom{SortTypedSymbol{}}()) [constructor{}()] // no junk + axiom{} \or{SortSymbolicElement{}} (\exists{SortSymbolicElement{}} (X0:SortSymbolicData{}, \exists{SortSymbolicElement{}} (X1:SortType{}, Lbl'Hash'SymbolicElement'LParUndsCommUndsRParUnds'MICHELSON'Unds'SymbolicElement'Unds'SymbolicData'Unds'Type{}(X0:SortSymbolicData{}, X1:SortType{}))), \bottom{SortSymbolicElement{}}()) [constructor{}()] // no junk + axiom{} \or{SortTimestamp{}} (\exists{SortTimestamp{}} (X0:SortInt{}, Lbl'Hash'Timestamp'LParUndsRParUnds'MICHELSON-COMMON'Unds'Timestamp'Unds'Int{}(X0:SortInt{})), \bottom{SortTimestamp{}}()) [constructor{}()] // no junk + axiom{} \or{SortMichelsonBool{}} (\top{SortMichelsonBool{}}(), \bottom{SortMichelsonBool{}}()) [constructor{}()] // no junk (TODO: fix bug with \dv) + axiom{} \or{SortKConfigVar{}} (\top{SortKConfigVar{}}(), \bottom{SortKConfigVar{}}()) [constructor{}()] // no junk (TODO: fix bug with \dv) + axiom{} \or{SortKeyHash{}} (\exists{SortKeyHash{}} (X0:SortString{}, Lbl'Hash'KeyHash'LParUndsRParUnds'MICHELSON-COMMON'Unds'KeyHash'Unds'String{}(X0:SortString{})), \bottom{SortKeyHash{}}()) [constructor{}()] // no junk + axiom{} \or{SortIOInt{}} (\exists{SortIOInt{}} (Val:SortInt{}, inj{SortInt{}, SortIOInt{}} (Val:SortInt{})), \or{SortIOInt{}} (\exists{SortIOInt{}} (Val:SortIOError{}, inj{SortIOError{}, SortIOInt{}} (Val:SortIOError{})), \bottom{SortIOInt{}}())) [constructor{}()] // no junk + axiom{} \or{SortPreType{}} (Lbl'Hash'NotSet'Unds'MICHELSON-COMMON'Unds'PreType{}(), \or{SortPreType{}} (\exists{SortPreType{}} (Val:SortType{}, inj{SortType{}, SortPreType{}} (Val:SortType{})), \bottom{SortPreType{}}())) [constructor{}()] // no junk + axiom{} \or{SortMyamountCellOpt{}} (LblnoMyamountCell{}(), \or{SortMyamountCellOpt{}} (\exists{SortMyamountCellOpt{}} (Val:SortMyamountCell{}, inj{SortMyamountCell{}, SortMyamountCellOpt{}} (Val:SortMyamountCell{})), \bottom{SortMyamountCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortCutpointsCell{}} (\exists{SortCutpointsCell{}} (X0:SortSet{}, Lbl'-LT-'cutpoints'-GT-'{}(X0:SortSet{})), \bottom{SortCutpointsCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortMybalanceCellOpt{}} (LblnoMybalanceCell{}(), \or{SortMybalanceCellOpt{}} (\exists{SortMybalanceCellOpt{}} (Val:SortMybalanceCell{}, inj{SortMybalanceCell{}, SortMybalanceCellOpt{}} (Val:SortMybalanceCell{})), \bottom{SortMybalanceCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortBlockchainOperation{}} (\exists{SortBlockchainOperation{}} (X0:SortInt{}, \exists{SortBlockchainOperation{}} (X1:SortContract{}, \exists{SortBlockchainOperation{}} (X2:SortOptionData{}, \exists{SortBlockchainOperation{}} (X3:SortMutez{}, \exists{SortBlockchainOperation{}} (X4:SortData{}, LblCreate'Unds'contract'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Contract'Unds'OptionData'Unds'Mutez'Unds'Data{}(X0:SortInt{}, X1:SortContract{}, X2:SortOptionData{}, X3:SortMutez{}, X4:SortData{})))))), \or{SortBlockchainOperation{}} (\exists{SortBlockchainOperation{}} (X0:SortInt{}, \exists{SortBlockchainOperation{}} (X1:SortOptionData{}, LblSet'Unds'delegate'LParUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'OptionData{}(X0:SortInt{}, X1:SortOptionData{}))), \or{SortBlockchainOperation{}} (\exists{SortBlockchainOperation{}} (X0:SortInt{}, \exists{SortBlockchainOperation{}} (X1:SortData{}, \exists{SortBlockchainOperation{}} (X2:SortMutez{}, \exists{SortBlockchainOperation{}} (X3:SortAddress{}, LblTransfer'Unds'tokens'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Data'Unds'Mutez'Unds'Address{}(X0:SortInt{}, X1:SortData{}, X2:SortMutez{}, X3:SortAddress{}))))), \bottom{SortBlockchainOperation{}}()))) [constructor{}()] // no junk + axiom{} \or{SortExpectedCellOpt{}} (LblnoExpectedCell{}(), \or{SortExpectedCellOpt{}} (\exists{SortExpectedCellOpt{}} (Val:SortExpectedCell{}, inj{SortExpectedCell{}, SortExpectedCellOpt{}} (Val:SortExpectedCell{})), \bottom{SortExpectedCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortBigMapGroup{}} (\exists{SortBigMapGroup{}} (X0:SortBigMapEntryList{}, Lblbig'Unds'maps'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapGroup'Unds'BigMapEntryList{}(X0:SortBigMapEntryList{})), \bottom{SortBigMapGroup{}}()) [constructor{}()] // no junk + axiom{} \or{SortContractData{}} (\exists{SortContractData{}} (X0:SortAddress{}, \exists{SortContractData{}} (X1:SortType{}, Lbl'Hash'Contract'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'ContractData'Unds'Address'Unds'Type{}(X0:SortAddress{}, X1:SortType{}))), \bottom{SortContractData{}}()) [constructor{}()] // no junk + axiom{} \or{SortKnownaddrsCell{}} (\exists{SortKnownaddrsCell{}} (X0:SortMap{}, Lbl'-LT-'knownaddrs'-GT-'{}(X0:SortMap{})), \bottom{SortKnownaddrsCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortError{}} (\exists{SortError{}} (X0:SortString{}, \exists{SortError{}} (X1:SortKItem{}, \exists{SortError{}} (X2:SortK{}, \exists{SortError{}} (X3:SortK{}, LblAborted'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Error'Unds'String'Unds'KItem'Unds'K'Unds'K{}(X0:SortString{}, X1:SortKItem{}, X2:SortK{}, X3:SortK{}))))), \bottom{SortError{}}()) [constructor{}()] // no junk + axiom{} \or{SortSimpleData{}} (LblUnit'Unds'MICHELSON-COMMON-SYNTAX'Unds'SimpleData{}(), \or{SortSimpleData{}} (\exists{SortSimpleData{}} (Val:SortList{}, inj{SortList{}, SortSimpleData{}} (Val:SortList{})), \or{SortSimpleData{}} (\exists{SortSimpleData{}} (Val:SortMBytesLiteral{}, inj{SortMBytesLiteral{}, SortSimpleData{}} (Val:SortMBytesLiteral{})), \or{SortSimpleData{}} (\exists{SortSimpleData{}} (Val:SortKey{}, inj{SortKey{}, SortSimpleData{}} (Val:SortKey{})), \or{SortSimpleData{}} (\exists{SortSimpleData{}} (Val:SortString{}, inj{SortString{}, SortSimpleData{}} (Val:SortString{})), \or{SortSimpleData{}} (\exists{SortSimpleData{}} (Val:SortTimestamp{}, inj{SortTimestamp{}, SortSimpleData{}} (Val:SortTimestamp{})), \or{SortSimpleData{}} (\exists{SortSimpleData{}} (Val:SortKeyHash{}, inj{SortKeyHash{}, SortSimpleData{}} (Val:SortKeyHash{})), \or{SortSimpleData{}} (\exists{SortSimpleData{}} (Val:SortBlockchainOperation{}, inj{SortBlockchainOperation{}, SortSimpleData{}} (Val:SortBlockchainOperation{})), \or{SortSimpleData{}} (\exists{SortSimpleData{}} (Val:SortContractData{}, inj{SortContractData{}, SortSimpleData{}} (Val:SortContractData{})), \or{SortSimpleData{}} (\exists{SortSimpleData{}} (Val:SortMutez{}, inj{SortMutez{}, SortSimpleData{}} (Val:SortMutez{})), \or{SortSimpleData{}} (\exists{SortSimpleData{}} (Val:SortAddress{}, inj{SortAddress{}, SortSimpleData{}} (Val:SortAddress{})), \or{SortSimpleData{}} (\exists{SortSimpleData{}} (Val:SortBool{}, inj{SortBool{}, SortSimpleData{}} (Val:SortBool{})), \or{SortSimpleData{}} (\exists{SortSimpleData{}} (Val:SortMap{}, inj{SortMap{}, SortSimpleData{}} (Val:SortMap{})), \or{SortSimpleData{}} (\exists{SortSimpleData{}} (Val:SortInt{}, inj{SortInt{}, SortSimpleData{}} (Val:SortInt{})), \or{SortSimpleData{}} (\exists{SortSimpleData{}} (Val:SortSignature{}, inj{SortSignature{}, SortSimpleData{}} (Val:SortSignature{})), \or{SortSimpleData{}} (\exists{SortSimpleData{}} (Val:SortLambdaData{}, inj{SortLambdaData{}, SortSimpleData{}} (Val:SortLambdaData{})), \or{SortSimpleData{}} (\exists{SortSimpleData{}} (Val:SortSet{}, inj{SortSet{}, SortSimpleData{}} (Val:SortSet{})), \or{SortSimpleData{}} (\exists{SortSimpleData{}} (Val:SortChainId{}, inj{SortChainId{}, SortSimpleData{}} (Val:SortChainId{})), \or{SortSimpleData{}} (\exists{SortSimpleData{}} (Val:SortMBytes{}, inj{SortMBytes{}, SortSimpleData{}} (Val:SortMBytes{})), \or{SortSimpleData{}} (\exists{SortSimpleData{}} (Val:SortBytes{}, inj{SortBytes{}, SortSimpleData{}} (Val:SortBytes{})), \bottom{SortSimpleData{}}())))))))))))))))))))) [constructor{}()] // no junk + axiom{} \or{SortParamvalueCell{}} (\exists{SortParamvalueCell{}} (X0:SortPreData{}, Lbl'-LT-'paramvalue'-GT-'{}(X0:SortPreData{})), \bottom{SortParamvalueCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortMutez{}} (\exists{SortMutez{}} (X0:SortInt{}, Lbl'Hash'Mutez'LParUndsRParUnds'MICHELSON-COMMON'Unds'Mutez'Unds'Int{}(X0:SortInt{})), \or{SortMutez{}} (\exists{SortMutez{}} (Val:SortInt{}, inj{SortInt{}, SortMutez{}} (Val:SortInt{})), \bottom{SortMutez{}}())) [constructor{}()] // no junk + axiom{} \or{SortBoolExp{}} (\exists{SortBoolExp{}} (X0:SortKItem{}, \exists{SortBoolExp{}} (X1:SortData{}, Lbl'UndsEqlsEqlsUndsUnds'MICHELSON'Unds'BoolExp'Unds'KItem'Unds'Data{}(X0:SortKItem{}, X1:SortData{}))), \or{SortBoolExp{}} (\exists{SortBoolExp{}} (Val:SortBool{}, inj{SortBool{}, SortBoolExp{}} (Val:SortBool{})), \bottom{SortBoolExp{}}())) [constructor{}()] // no junk + axiom{} \or{SortStackCellOpt{}} (LblnoStackCell{}(), \or{SortStackCellOpt{}} (\exists{SortStackCellOpt{}} (Val:SortStackCell{}, inj{SortStackCell{}, SortStackCellOpt{}} (Val:SortStackCell{})), \bottom{SortStackCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortPreData{}} (Lbl'Hash'NoData'Unds'MICHELSON-COMMON'Unds'PreData{}(), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortInstruction{}, inj{SortInstruction{}, SortPreData{}} (Val:SortInstruction{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortMapLiteral{}, inj{SortMapLiteral{}, SortPreData{}} (Val:SortMapLiteral{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortData{}, inj{SortData{}, SortPreData{}} (Val:SortData{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortList{}, inj{SortList{}, SortPreData{}} (Val:SortList{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortMBytesLiteral{}, inj{SortMBytesLiteral{}, SortPreData{}} (Val:SortMBytesLiteral{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortKey{}, inj{SortKey{}, SortPreData{}} (Val:SortKey{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortTypedData{}, inj{SortTypedData{}, SortPreData{}} (Val:SortTypedData{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortString{}, inj{SortString{}, SortPreData{}} (Val:SortString{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortTimestamp{}, inj{SortTimestamp{}, SortPreData{}} (Val:SortTimestamp{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortKeyHash{}, inj{SortKeyHash{}, SortPreData{}} (Val:SortKeyHash{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortBlockchainOperation{}, inj{SortBlockchainOperation{}, SortPreData{}} (Val:SortBlockchainOperation{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortContractData{}, inj{SortContractData{}, SortPreData{}} (Val:SortContractData{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortSimpleData{}, inj{SortSimpleData{}, SortPreData{}} (Val:SortSimpleData{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortMutez{}, inj{SortMutez{}, SortPreData{}} (Val:SortMutez{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortAddress{}, inj{SortAddress{}, SortPreData{}} (Val:SortAddress{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortSequenceData{}, inj{SortSequenceData{}, SortPreData{}} (Val:SortSequenceData{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortEmptyBlock{}, inj{SortEmptyBlock{}, SortPreData{}} (Val:SortEmptyBlock{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortBool{}, inj{SortBool{}, SortPreData{}} (Val:SortBool{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortOrData{}, inj{SortOrData{}, SortPreData{}} (Val:SortOrData{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortOptionData{}, inj{SortOptionData{}, SortPreData{}} (Val:SortOptionData{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortMap{}, inj{SortMap{}, SortPreData{}} (Val:SortMap{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortInt{}, inj{SortInt{}, SortPreData{}} (Val:SortInt{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortPair{}, inj{SortPair{}, SortPreData{}} (Val:SortPair{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortSignature{}, inj{SortSignature{}, SortPreData{}} (Val:SortSignature{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortLambdaData{}, inj{SortLambdaData{}, SortPreData{}} (Val:SortLambdaData{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortBlock{}, inj{SortBlock{}, SortPreData{}} (Val:SortBlock{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortSet{}, inj{SortSet{}, SortPreData{}} (Val:SortSet{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortChainId{}, inj{SortChainId{}, SortPreData{}} (Val:SortChainId{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortMBytes{}, inj{SortMBytes{}, SortPreData{}} (Val:SortMBytes{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortSymbolicData{}, inj{SortSymbolicData{}, SortPreData{}} (Val:SortSymbolicData{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortBytes{}, inj{SortBytes{}, SortPreData{}} (Val:SortBytes{})), \or{SortPreData{}} (\exists{SortPreData{}} (Val:SortFailedStack{}, inj{SortFailedStack{}, SortPreData{}} (Val:SortFailedStack{})), \bottom{SortPreData{}}()))))))))))))))))))))))))))))))))) [constructor{}()] // no junk + axiom{} \or{SortSymbolsCell{}} (\exists{SortSymbolsCell{}} (X0:SortMap{}, Lbl'-LT-'symbols'-GT-'{}(X0:SortMap{})), \bottom{SortSymbolsCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortGeneratedCounterCellOpt{}} (LblnoGeneratedCounterCell{}(), \or{SortGeneratedCounterCellOpt{}} (\exists{SortGeneratedCounterCellOpt{}} (Val:SortGeneratedCounterCell{}, inj{SortGeneratedCounterCell{}, SortGeneratedCounterCellOpt{}} (Val:SortGeneratedCounterCell{})), \bottom{SortGeneratedCounterCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortBigMapEntry{}} (\exists{SortBigMapEntry{}} (X0:SortInt{}, \exists{SortBigMapEntry{}} (X1:SortType{}, \exists{SortBigMapEntry{}} (X2:SortType{}, \exists{SortBigMapEntry{}} (X3:SortEmptyBlock{}, LblBig'Unds'map'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntry'Unds'Int'Unds'Type'Unds'Type'Unds'EmptyBlock{}(X0:SortInt{}, X1:SortType{}, X2:SortType{}, X3:SortEmptyBlock{}))))), \or{SortBigMapEntry{}} (\exists{SortBigMapEntry{}} (X0:SortInt{}, \exists{SortBigMapEntry{}} (X1:SortType{}, \exists{SortBigMapEntry{}} (X2:SortType{}, \exists{SortBigMapEntry{}} (X3:SortMapLiteral{}, LblBig'Unds'map'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntry'Unds'Int'Unds'Type'Unds'Type'Unds'MapLiteral{}(X0:SortInt{}, X1:SortType{}, X2:SortType{}, X3:SortMapLiteral{}))))), \bottom{SortBigMapEntry{}}())) [constructor{}()] // no junk + axiom{} \or{SortUnifiedList{}} (\exists{SortUnifiedList{}} (Val:SortList{}, inj{SortList{}, SortUnifiedList{}} (Val:SortList{})), \or{SortUnifiedList{}} (\exists{SortUnifiedList{}} (Val:SortUnificationFailure{}, inj{SortUnificationFailure{}, SortUnifiedList{}} (Val:SortUnificationFailure{})), \bottom{SortUnifiedList{}}())) [constructor{}()] // no junk + axiom{} \or{SortAddress{}} (\exists{SortAddress{}} (X0:SortString{}, Lbl'Hash'Address'LParUndsRParUnds'MICHELSON-COMMON'Unds'Address'Unds'String{}(X0:SortString{})), \or{SortAddress{}} (\exists{SortAddress{}} (Val:SortString{}, inj{SortString{}, SortAddress{}} (Val:SortString{})), \bottom{SortAddress{}}())) [constructor{}()] // no junk + axiom{} \bottom{SortSimpleType{}}() [constructor{}()] // no junk + axiom{} \or{SortMyamountCell{}} (\exists{SortMyamountCell{}} (X0:SortMutez{}, Lbl'-LT-'myamount'-GT-'{}(X0:SortMutez{})), \bottom{SortMyamountCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortParamvalueCellOpt{}} (LblnoParamvalueCell{}(), \or{SortParamvalueCellOpt{}} (\exists{SortParamvalueCellOpt{}} (Val:SortParamvalueCell{}, inj{SortParamvalueCell{}, SortParamvalueCellOpt{}} (Val:SortParamvalueCell{})), \bottom{SortParamvalueCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortInstruction{}, inj{SortInstruction{}, SortDataOrSeq{}} (Val:SortInstruction{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortMapLiteral{}, inj{SortMapLiteral{}, SortDataOrSeq{}} (Val:SortMapLiteral{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortData{}, inj{SortData{}, SortDataOrSeq{}} (Val:SortData{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortList{}, inj{SortList{}, SortDataOrSeq{}} (Val:SortList{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortMBytesLiteral{}, inj{SortMBytesLiteral{}, SortDataOrSeq{}} (Val:SortMBytesLiteral{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortKey{}, inj{SortKey{}, SortDataOrSeq{}} (Val:SortKey{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortTypedData{}, inj{SortTypedData{}, SortDataOrSeq{}} (Val:SortTypedData{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortString{}, inj{SortString{}, SortDataOrSeq{}} (Val:SortString{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortTimestamp{}, inj{SortTimestamp{}, SortDataOrSeq{}} (Val:SortTimestamp{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortKeyHash{}, inj{SortKeyHash{}, SortDataOrSeq{}} (Val:SortKeyHash{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortBlockchainOperation{}, inj{SortBlockchainOperation{}, SortDataOrSeq{}} (Val:SortBlockchainOperation{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortContractData{}, inj{SortContractData{}, SortDataOrSeq{}} (Val:SortContractData{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortSimpleData{}, inj{SortSimpleData{}, SortDataOrSeq{}} (Val:SortSimpleData{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortMutez{}, inj{SortMutez{}, SortDataOrSeq{}} (Val:SortMutez{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortAddress{}, inj{SortAddress{}, SortDataOrSeq{}} (Val:SortAddress{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortSequenceData{}, inj{SortSequenceData{}, SortDataOrSeq{}} (Val:SortSequenceData{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortEmptyBlock{}, inj{SortEmptyBlock{}, SortDataOrSeq{}} (Val:SortEmptyBlock{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortBool{}, inj{SortBool{}, SortDataOrSeq{}} (Val:SortBool{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortOrData{}, inj{SortOrData{}, SortDataOrSeq{}} (Val:SortOrData{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortOptionData{}, inj{SortOptionData{}, SortDataOrSeq{}} (Val:SortOptionData{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortMap{}, inj{SortMap{}, SortDataOrSeq{}} (Val:SortMap{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortMapEntryList{}, inj{SortMapEntryList{}, SortDataOrSeq{}} (Val:SortMapEntryList{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortMapEntry{}, inj{SortMapEntry{}, SortDataOrSeq{}} (Val:SortMapEntry{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortDataList{}, inj{SortDataList{}, SortDataOrSeq{}} (Val:SortDataList{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortInt{}, inj{SortInt{}, SortDataOrSeq{}} (Val:SortInt{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortPair{}, inj{SortPair{}, SortDataOrSeq{}} (Val:SortPair{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortSignature{}, inj{SortSignature{}, SortDataOrSeq{}} (Val:SortSignature{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortLambdaData{}, inj{SortLambdaData{}, SortDataOrSeq{}} (Val:SortLambdaData{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortBlock{}, inj{SortBlock{}, SortDataOrSeq{}} (Val:SortBlock{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortSet{}, inj{SortSet{}, SortDataOrSeq{}} (Val:SortSet{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortChainId{}, inj{SortChainId{}, SortDataOrSeq{}} (Val:SortChainId{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortMBytes{}, inj{SortMBytes{}, SortDataOrSeq{}} (Val:SortMBytes{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortSymbolicData{}, inj{SortSymbolicData{}, SortDataOrSeq{}} (Val:SortSymbolicData{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortBytes{}, inj{SortBytes{}, SortDataOrSeq{}} (Val:SortBytes{})), \or{SortDataOrSeq{}} (\exists{SortDataOrSeq{}} (Val:SortFailedStack{}, inj{SortFailedStack{}, SortDataOrSeq{}} (Val:SortFailedStack{})), \bottom{SortDataOrSeq{}}()))))))))))))))))))))))))))))))))))) [constructor{}()] // no junk + axiom{} \or{SortCutpointsCellOpt{}} (LblnoCutpointsCell{}(), \or{SortCutpointsCellOpt{}} (\exists{SortCutpointsCellOpt{}} (Val:SortCutpointsCell{}, inj{SortCutpointsCell{}, SortCutpointsCellOpt{}} (Val:SortCutpointsCell{})), \bottom{SortCutpointsCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortGeneratedCounterCell{}} (\exists{SortGeneratedCounterCell{}} (X0:SortInt{}, Lbl'-LT-'generatedCounter'-GT-'{}(X0:SortInt{})), \bottom{SortGeneratedCounterCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortSenderGroup{}} (\exists{SortSenderGroup{}} (X0:SortString{}, Lblsender'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'SenderGroup'Unds'String{}(X0:SortString{})), \bottom{SortSenderGroup{}}()) [constructor{}()] // no junk + axiom{} \or{SortGroups{}} (\exists{SortGroups{}} (X0:SortGroup{}, \exists{SortGroups{}} (X1:SortGroups{}, Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Groups'Unds'Group'Unds'Groups{}(X0:SortGroup{}, X1:SortGroups{}))), \or{SortGroups{}} (\exists{SortGroups{}} (X0:SortGroup{}, LblgroupSemicolon{}(X0:SortGroup{})), \or{SortGroups{}} (\exists{SortGroups{}} (Val:SortSourceGroup{}, inj{SortSourceGroup{}, SortGroups{}} (Val:SortSourceGroup{})), \or{SortGroups{}} (\exists{SortGroups{}} (Val:SortInputGroup{}, inj{SortInputGroup{}, SortGroups{}} (Val:SortInputGroup{})), \or{SortGroups{}} (\exists{SortGroups{}} (Val:SortBigMapGroup{}, inj{SortBigMapGroup{}, SortGroups{}} (Val:SortBigMapGroup{})), \or{SortGroups{}} (\exists{SortGroups{}} (Val:SortSenderGroup{}, inj{SortSenderGroup{}, SortGroups{}} (Val:SortSenderGroup{})), \or{SortGroups{}} (\exists{SortGroups{}} (Val:SortParameterValueGroup{}, inj{SortParameterValueGroup{}, SortGroups{}} (Val:SortParameterValueGroup{})), \or{SortGroups{}} (\exists{SortGroups{}} (Val:SortParameterDecl{}, inj{SortParameterDecl{}, SortGroups{}} (Val:SortParameterDecl{})), \or{SortGroups{}} (\exists{SortGroups{}} (Val:SortPreconditionGroup{}, inj{SortPreconditionGroup{}, SortGroups{}} (Val:SortPreconditionGroup{})), \or{SortGroups{}} (\exists{SortGroups{}} (Val:SortNowGroup{}, inj{SortNowGroup{}, SortGroups{}} (Val:SortNowGroup{})), \or{SortGroups{}} (\exists{SortGroups{}} (Val:SortStorageValueGroup{}, inj{SortStorageValueGroup{}, SortGroups{}} (Val:SortStorageValueGroup{})), \or{SortGroups{}} (\exists{SortGroups{}} (Val:SortInvariantsGroup{}, inj{SortInvariantsGroup{}, SortGroups{}} (Val:SortInvariantsGroup{})), \or{SortGroups{}} (\exists{SortGroups{}} (Val:SortSelfGroup{}, inj{SortSelfGroup{}, SortGroups{}} (Val:SortSelfGroup{})), \or{SortGroups{}} (\exists{SortGroups{}} (Val:SortStorageDecl{}, inj{SortStorageDecl{}, SortGroups{}} (Val:SortStorageDecl{})), \or{SortGroups{}} (\exists{SortGroups{}} (Val:SortGroup{}, inj{SortGroup{}, SortGroups{}} (Val:SortGroup{})), \or{SortGroups{}} (\exists{SortGroups{}} (Val:SortParameterGroup{}, inj{SortParameterGroup{}, SortGroups{}} (Val:SortParameterGroup{})), \or{SortGroups{}} (\exists{SortGroups{}} (Val:SortOutputGroup{}, inj{SortOutputGroup{}, SortGroups{}} (Val:SortOutputGroup{})), \or{SortGroups{}} (\exists{SortGroups{}} (Val:SortCodeDecl{}, inj{SortCodeDecl{}, SortGroups{}} (Val:SortCodeDecl{})), \or{SortGroups{}} (\exists{SortGroups{}} (Val:SortBalanceGroup{}, inj{SortBalanceGroup{}, SortGroups{}} (Val:SortBalanceGroup{})), \or{SortGroups{}} (\exists{SortGroups{}} (Val:SortChainGroup{}, inj{SortChainGroup{}, SortGroups{}} (Val:SortChainGroup{})), \or{SortGroups{}} (\exists{SortGroups{}} (Val:SortContractGroup{}, inj{SortContractGroup{}, SortGroups{}} (Val:SortContractGroup{})), \or{SortGroups{}} (\exists{SortGroups{}} (Val:SortContractsGroup{}, inj{SortContractsGroup{}, SortGroups{}} (Val:SortContractsGroup{})), \or{SortGroups{}} (\exists{SortGroups{}} (Val:SortAmountGroup{}, inj{SortAmountGroup{}, SortGroups{}} (Val:SortAmountGroup{})), \or{SortGroups{}} (\exists{SortGroups{}} (Val:SortPostconditionGroup{}, inj{SortPostconditionGroup{}, SortGroups{}} (Val:SortPostconditionGroup{})), \or{SortGroups{}} (\exists{SortGroups{}} (Val:SortCodeGroup{}, inj{SortCodeGroup{}, SortGroups{}} (Val:SortCodeGroup{})), \bottom{SortGroups{}}()))))))))))))))))))))))))) [constructor{}()] // no junk + axiom{} \or{SortSequenceData{}} (\exists{SortSequenceData{}} (Val:SortMapLiteral{}, inj{SortMapLiteral{}, SortSequenceData{}} (Val:SortMapLiteral{})), \or{SortSequenceData{}} (\exists{SortSequenceData{}} (Val:SortEmptyBlock{}, inj{SortEmptyBlock{}, SortSequenceData{}} (Val:SortEmptyBlock{})), \or{SortSequenceData{}} (\exists{SortSequenceData{}} (Val:SortBlock{}, inj{SortBlock{}, SortSequenceData{}} (Val:SortBlock{})), \bottom{SortSequenceData{}}()))) [constructor{}()] // no junk + axiom{} \or{SortUnaryTypeName{}} (Lblcontract'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(), \or{SortUnaryTypeName{}} (Lbllist'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(), \or{SortUnaryTypeName{}} (Lbloption'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(), \or{SortUnaryTypeName{}} (Lblset'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(), \bottom{SortUnaryTypeName{}}())))) [constructor{}()] // no junk + axiom{} \or{SortId{}} (\top{SortId{}}(), \bottom{SortId{}}()) [constructor{}()] // no junk (TODO: fix bug with \dv) + axiom{} \or{SortSenderaddrCellOpt{}} (LblnoSenderaddrCell{}(), \or{SortSenderaddrCellOpt{}} (\exists{SortSenderaddrCellOpt{}} (Val:SortSenderaddrCell{}, inj{SortSenderaddrCell{}, SortSenderaddrCellOpt{}} (Val:SortSenderaddrCell{})), \bottom{SortSenderaddrCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortEmptyBlock{}} (Lbl'LBraRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'EmptyBlock{}(), \bottom{SortEmptyBlock{}}()) [constructor{}()] // no junk + axiom{} \or{SortSignedness{}} (LblsignedBytes{}(), \or{SortSignedness{}} (LblunsignedBytes{}(), \bottom{SortSignedness{}}())) [constructor{}()] // no junk + axiom{} \or{SortSourceaddrCellOpt{}} (LblnoSourceaddrCell{}(), \or{SortSourceaddrCellOpt{}} (\exists{SortSourceaddrCellOpt{}} (Val:SortSourceaddrCell{}, inj{SortSourceaddrCell{}, SortSourceaddrCellOpt{}} (Val:SortSourceaddrCell{})), \bottom{SortSourceaddrCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortSourceaddrCell{}} (\exists{SortSourceaddrCell{}} (X0:SortAddress{}, Lbl'-LT-'sourceaddr'-GT-'{}(X0:SortAddress{})), \bottom{SortSourceaddrCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortNullaryTypeName{}} (Lbladdress'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), \or{SortNullaryTypeName{}} (Lblbool'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), \or{SortNullaryTypeName{}} (Lblbytes'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), \or{SortNullaryTypeName{}} (Lblchain'Unds'id'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), \or{SortNullaryTypeName{}} (Lblkey'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), \or{SortNullaryTypeName{}} (Lblkey'Unds'hash'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), \or{SortNullaryTypeName{}} (Lblmutez'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), \or{SortNullaryTypeName{}} (Lbloperation'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), \or{SortNullaryTypeName{}} (Lblsignature'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), \or{SortNullaryTypeName{}} (Lblstring'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), \or{SortNullaryTypeName{}} (Lbltimestamp'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), \or{SortNullaryTypeName{}} (Lblunit'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(), \or{SortNullaryTypeName{}} (\exists{SortNullaryTypeName{}} (Val:SortNumTypeName{}, inj{SortNumTypeName{}, SortNullaryTypeName{}} (Val:SortNumTypeName{})), \bottom{SortNullaryTypeName{}}()))))))))))))) [constructor{}()] // no junk + axiom{} \or{SortStackElementList{}} (Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'StackElementList'Unds'StackElementLiteral'Unds'StackElementList'QuotRBraUnds'StackElementList{}(), \or{SortStackElementList{}} (\exists{SortStackElementList{}} (X0:SortStackElementLiteral{}, \exists{SortStackElementList{}} (X1:SortStackElementList{}, Lbl'UndsSClnUndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'StackElementList'Unds'StackElementLiteral'Unds'StackElementList{}(X0:SortStackElementLiteral{}, X1:SortStackElementList{}))), \bottom{SortStackElementList{}}())) [constructor{}()] // no junk + axiom{} \or{SortStream{}} (\exists{SortStream{}} (X0:SortK{}, Lbl'Hash'buffer'LParUndsRParUnds'K-IO'Unds'Stream'Unds'K{}(X0:SortK{})), \bottom{SortStream{}}()) [constructor{}()] // no junk + axiom{} \or{SortCell{}} (\exists{SortCell{}} (Val:SortScriptCell{}, inj{SortScriptCell{}, SortCell{}} (Val:SortScriptCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortMybalanceCell{}, inj{SortMybalanceCell{}, SortCell{}} (Val:SortMybalanceCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortExpectedCell{}, inj{SortExpectedCell{}, SortCell{}} (Val:SortExpectedCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortMychainidCell{}, inj{SortMychainidCell{}, SortCell{}} (Val:SortMychainidCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortPreCell{}, inj{SortPreCell{}, SortCell{}} (Val:SortPreCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortStoragetypeCell{}, inj{SortStoragetypeCell{}, SortCell{}} (Val:SortStoragetypeCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortMyaddrCell{}, inj{SortMyaddrCell{}, SortCell{}} (Val:SortMyaddrCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortCutpointsCell{}, inj{SortCutpointsCell{}, SortCell{}} (Val:SortCutpointsCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortKnownaddrsCell{}, inj{SortKnownaddrsCell{}, SortCell{}} (Val:SortKnownaddrsCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortParamvalueCell{}, inj{SortParamvalueCell{}, SortCell{}} (Val:SortParamvalueCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortSymbolsCell{}, inj{SortSymbolsCell{}, SortCell{}} (Val:SortSymbolsCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortMyamountCell{}, inj{SortMyamountCell{}, SortCell{}} (Val:SortMyamountCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortSourceaddrCell{}, inj{SortSourceaddrCell{}, SortCell{}} (Val:SortSourceaddrCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortMynowCell{}, inj{SortMynowCell{}, SortCell{}} (Val:SortMynowCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortKCell{}, inj{SortKCell{}, SortCell{}} (Val:SortKCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortPostCell{}, inj{SortPostCell{}, SortCell{}} (Val:SortPostCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortTraceCell{}, inj{SortTraceCell{}, SortCell{}} (Val:SortTraceCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortMichelsonTopCell{}, inj{SortMichelsonTopCell{}, SortCell{}} (Val:SortMichelsonTopCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortReturncodeCell{}, inj{SortReturncodeCell{}, SortCell{}} (Val:SortReturncodeCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortStackCell{}, inj{SortStackCell{}, SortCell{}} (Val:SortStackCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortInputstackCell{}, inj{SortInputstackCell{}, SortCell{}} (Val:SortInputstackCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortBigmapsCell{}, inj{SortBigmapsCell{}, SortCell{}} (Val:SortBigmapsCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortInvsCell{}, inj{SortInvsCell{}, SortCell{}} (Val:SortInvsCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortNonceCell{}, inj{SortNonceCell{}, SortCell{}} (Val:SortNonceCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortStoragevalueCell{}, inj{SortStoragevalueCell{}, SortCell{}} (Val:SortStoragevalueCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortParamtypeCell{}, inj{SortParamtypeCell{}, SortCell{}} (Val:SortParamtypeCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortAssumeFailedCell{}, inj{SortAssumeFailedCell{}, SortCell{}} (Val:SortAssumeFailedCell{})), \or{SortCell{}} (\exists{SortCell{}} (Val:SortSenderaddrCell{}, inj{SortSenderaddrCell{}, SortCell{}} (Val:SortSenderaddrCell{})), \bottom{SortCell{}}())))))))))))))))))))))))))))) [constructor{}()] // no junk + axiom{} \or{SortBool{}} (\top{SortBool{}}(), \bottom{SortBool{}}()) [constructor{}()] // no junk (TODO: fix bug with \dv) + axiom{} \or{SortMynowCell{}} (\exists{SortMynowCell{}} (X0:SortTimestamp{}, Lbl'-LT-'mynow'-GT-'{}(X0:SortTimestamp{})), \bottom{SortMynowCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortOtherContractsMapEntry{}} (\exists{SortOtherContractsMapEntry{}} (X0:SortString{}, \exists{SortOtherContractsMapEntry{}} (X1:SortType{}, LblElt'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OtherContractsMapEntry'Unds'String'Unds'Type{}(X0:SortString{}, X1:SortType{}))), \bottom{SortOtherContractsMapEntry{}}()) [constructor{}()] // no junk + axiom{} \or{SortKCell{}} (\exists{SortKCell{}} (X0:SortK{}, Lbl'-LT-'k'-GT-'{}(X0:SortK{})), \bottom{SortKCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortParameterValueGroup{}} (\exists{SortParameterValueGroup{}} (X0:SortData{}, Lblparameter'Unds'value'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'ParameterValueGroup'Unds'Data{}(X0:SortData{})), \bottom{SortParameterValueGroup{}}()) [constructor{}()] // no junk + axiom{} \bottom{SortK{}}() [constructor{}()] // no junk + axiom{} \or{SortIOFile{}} (\exists{SortIOFile{}} (X0:SortString{}, \exists{SortIOFile{}} (X1:SortInt{}, Lbl'Hash'tempFile{}(X0:SortString{}, X1:SortInt{}))), \or{SortIOFile{}} (\exists{SortIOFile{}} (Val:SortIOError{}, inj{SortIOError{}, SortIOFile{}} (Val:SortIOError{})), \bottom{SortIOFile{}}())) [constructor{}()] // no junk + axiom{} \or{SortPostCell{}} (\exists{SortPostCell{}} (X0:SortBlockList{}, Lbl'-LT-'post'-GT-'{}(X0:SortBlockList{})), \bottom{SortPostCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortParameterDecl{}} (\exists{SortParameterDecl{}} (X0:SortType{}, Lblparameter'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'ParameterDecl'Unds'Type{}(X0:SortType{})), \bottom{SortParameterDecl{}}()) [constructor{}()] // no junk + axiom{} \or{SortOrData{}} (\exists{SortOrData{}} (X0:SortData{}, LblLeft'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(X0:SortData{})), \or{SortOrData{}} (\exists{SortOrData{}} (X0:SortData{}, LblRight'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(X0:SortData{})), \bottom{SortOrData{}}())) [constructor{}()] // no junk + axiom{} \or{SortTraceCell{}} (\exists{SortTraceCell{}} (X0:SortK{}, Lbl'-LT-'trace'-GT-'{}(X0:SortK{})), \bottom{SortTraceCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortOptionData{}} (LblNone'Unds'MICHELSON-COMMON-SYNTAX'Unds'OptionData{}(), \or{SortOptionData{}} (\exists{SortOptionData{}} (X0:SortData{}, LblSome'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OptionData'Unds'Data{}(X0:SortData{})), \bottom{SortOptionData{}}())) [constructor{}()] // no junk + axiom{} \or{SortUnificationFailure{}} (Lbl'Hash'UnificationFailure'Unds'MICHELSON'Unds'UnificationFailure{}(), \bottom{SortUnificationFailure{}}()) [constructor{}()] // no junk + axiom{} \or{SortPreconditionGroup{}} (\exists{SortPreconditionGroup{}} (X0:SortBlockList{}, Lblprecondition'LBraUndsRBraUnds'SYMBOLIC-UNIT-TEST-COMMON-SYNTAX'Unds'PreconditionGroup'Unds'BlockList{}(X0:SortBlockList{})), \bottom{SortPreconditionGroup{}}()) [constructor{}()] // no junk + axiom{} \or{SortMaybeTypeName{}} (LblNoneType'Unds'MICHELSON'Unds'MaybeTypeName{}(), \or{SortMaybeTypeName{}} (\exists{SortMaybeTypeName{}} (Val:SortTypeName{}, inj{SortTypeName{}, SortMaybeTypeName{}} (Val:SortTypeName{})), \or{SortMaybeTypeName{}} (\exists{SortMaybeTypeName{}} (Val:SortNullaryTypeName{}, inj{SortNullaryTypeName{}, SortMaybeTypeName{}} (Val:SortNullaryTypeName{})), \or{SortMaybeTypeName{}} (\exists{SortMaybeTypeName{}} (Val:SortNumTypeName{}, inj{SortNumTypeName{}, SortMaybeTypeName{}} (Val:SortNumTypeName{})), \bottom{SortMaybeTypeName{}}())))) [constructor{}()] // no junk + axiom{} \or{SortKResult{}} (\exists{SortKResult{}} (Val:SortList{}, inj{SortList{}, SortKResult{}} (Val:SortList{})), \or{SortKResult{}} (\exists{SortKResult{}} (Val:SortMBytesLiteral{}, inj{SortMBytesLiteral{}, SortKResult{}} (Val:SortMBytesLiteral{})), \or{SortKResult{}} (\exists{SortKResult{}} (Val:SortKey{}, inj{SortKey{}, SortKResult{}} (Val:SortKey{})), \or{SortKResult{}} (\exists{SortKResult{}} (Val:SortString{}, inj{SortString{}, SortKResult{}} (Val:SortString{})), \or{SortKResult{}} (\exists{SortKResult{}} (Val:SortTimestamp{}, inj{SortTimestamp{}, SortKResult{}} (Val:SortTimestamp{})), \or{SortKResult{}} (\exists{SortKResult{}} (Val:SortKeyHash{}, inj{SortKeyHash{}, SortKResult{}} (Val:SortKeyHash{})), \or{SortKResult{}} (\exists{SortKResult{}} (Val:SortBlockchainOperation{}, inj{SortBlockchainOperation{}, SortKResult{}} (Val:SortBlockchainOperation{})), \or{SortKResult{}} (\exists{SortKResult{}} (Val:SortContractData{}, inj{SortContractData{}, SortKResult{}} (Val:SortContractData{})), \or{SortKResult{}} (\exists{SortKResult{}} (Val:SortSimpleData{}, inj{SortSimpleData{}, SortKResult{}} (Val:SortSimpleData{})), \or{SortKResult{}} (\exists{SortKResult{}} (Val:SortMutez{}, inj{SortMutez{}, SortKResult{}} (Val:SortMutez{})), \or{SortKResult{}} (\exists{SortKResult{}} (Val:SortAddress{}, inj{SortAddress{}, SortKResult{}} (Val:SortAddress{})), \or{SortKResult{}} (\exists{SortKResult{}} (Val:SortBool{}, inj{SortBool{}, SortKResult{}} (Val:SortBool{})), \or{SortKResult{}} (\exists{SortKResult{}} (Val:SortMap{}, inj{SortMap{}, SortKResult{}} (Val:SortMap{})), \or{SortKResult{}} (\exists{SortKResult{}} (Val:SortInt{}, inj{SortInt{}, SortKResult{}} (Val:SortInt{})), \or{SortKResult{}} (\exists{SortKResult{}} (Val:SortSignature{}, inj{SortSignature{}, SortKResult{}} (Val:SortSignature{})), \or{SortKResult{}} (\exists{SortKResult{}} (Val:SortLambdaData{}, inj{SortLambdaData{}, SortKResult{}} (Val:SortLambdaData{})), \or{SortKResult{}} (\exists{SortKResult{}} (Val:SortSet{}, inj{SortSet{}, SortKResult{}} (Val:SortSet{})), \or{SortKResult{}} (\exists{SortKResult{}} (Val:SortChainId{}, inj{SortChainId{}, SortKResult{}} (Val:SortChainId{})), \or{SortKResult{}} (\exists{SortKResult{}} (Val:SortMBytes{}, inj{SortMBytes{}, SortKResult{}} (Val:SortMBytes{})), \or{SortKResult{}} (\exists{SortKResult{}} (Val:SortBytes{}, inj{SortBytes{}, SortKResult{}} (Val:SortBytes{})), \bottom{SortKResult{}}())))))))))))))))))))) [constructor{}()] // no junk + axiom{} \or{SortContract{}} (\exists{SortContract{}} (X0:SortCodeDecl{}, \exists{SortContract{}} (X1:SortParameterDecl{}, \exists{SortContract{}} (X2:SortStorageDecl{}, Lbl'UndsSClnUndsSClnUndsSClnUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'CodeDecl'Unds'ParameterDecl'Unds'StorageDecl{}(X0:SortCodeDecl{}, X1:SortParameterDecl{}, X2:SortStorageDecl{})))), \or{SortContract{}} (\exists{SortContract{}} (X0:SortCodeDecl{}, \exists{SortContract{}} (X1:SortStorageDecl{}, \exists{SortContract{}} (X2:SortParameterDecl{}, Lbl'UndsSClnUndsSClnUndsSClnUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'CodeDecl'Unds'StorageDecl'Unds'ParameterDecl{}(X0:SortCodeDecl{}, X1:SortStorageDecl{}, X2:SortParameterDecl{})))), \or{SortContract{}} (\exists{SortContract{}} (X0:SortParameterDecl{}, \exists{SortContract{}} (X1:SortCodeDecl{}, \exists{SortContract{}} (X2:SortStorageDecl{}, Lbl'UndsSClnUndsSClnUndsSClnUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'ParameterDecl'Unds'CodeDecl'Unds'StorageDecl{}(X0:SortParameterDecl{}, X1:SortCodeDecl{}, X2:SortStorageDecl{})))), \or{SortContract{}} (\exists{SortContract{}} (X0:SortParameterDecl{}, \exists{SortContract{}} (X1:SortStorageDecl{}, \exists{SortContract{}} (X2:SortCodeDecl{}, Lbl'UndsSClnUndsSClnUndsSClnUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'ParameterDecl'Unds'StorageDecl'Unds'CodeDecl{}(X0:SortParameterDecl{}, X1:SortStorageDecl{}, X2:SortCodeDecl{})))), \or{SortContract{}} (\exists{SortContract{}} (X0:SortStorageDecl{}, \exists{SortContract{}} (X1:SortCodeDecl{}, \exists{SortContract{}} (X2:SortParameterDecl{}, Lbl'UndsSClnUndsSClnUndsSClnUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'StorageDecl'Unds'CodeDecl'Unds'ParameterDecl{}(X0:SortStorageDecl{}, X1:SortCodeDecl{}, X2:SortParameterDecl{})))), \or{SortContract{}} (\exists{SortContract{}} (X0:SortStorageDecl{}, \exists{SortContract{}} (X1:SortParameterDecl{}, \exists{SortContract{}} (X2:SortCodeDecl{}, Lbl'UndsSClnUndsSClnUndsSClnUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'StorageDecl'Unds'ParameterDecl'Unds'CodeDecl{}(X0:SortStorageDecl{}, X1:SortParameterDecl{}, X2:SortCodeDecl{})))), \or{SortContract{}} (\exists{SortContract{}} (X0:SortCodeDecl{}, \exists{SortContract{}} (X1:SortParameterDecl{}, \exists{SortContract{}} (X2:SortStorageDecl{}, Lbl'UndsSClnUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'CodeDecl'Unds'ParameterDecl'Unds'StorageDecl{}(X0:SortCodeDecl{}, X1:SortParameterDecl{}, X2:SortStorageDecl{})))), \or{SortContract{}} (\exists{SortContract{}} (X0:SortCodeDecl{}, \exists{SortContract{}} (X1:SortStorageDecl{}, \exists{SortContract{}} (X2:SortParameterDecl{}, Lbl'UndsSClnUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'CodeDecl'Unds'StorageDecl'Unds'ParameterDecl{}(X0:SortCodeDecl{}, X1:SortStorageDecl{}, X2:SortParameterDecl{})))), \or{SortContract{}} (\exists{SortContract{}} (X0:SortParameterDecl{}, \exists{SortContract{}} (X1:SortCodeDecl{}, \exists{SortContract{}} (X2:SortStorageDecl{}, Lbl'UndsSClnUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'ParameterDecl'Unds'CodeDecl'Unds'StorageDecl{}(X0:SortParameterDecl{}, X1:SortCodeDecl{}, X2:SortStorageDecl{})))), \or{SortContract{}} (\exists{SortContract{}} (X0:SortParameterDecl{}, \exists{SortContract{}} (X1:SortStorageDecl{}, \exists{SortContract{}} (X2:SortCodeDecl{}, Lbl'UndsSClnUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'ParameterDecl'Unds'StorageDecl'Unds'CodeDecl{}(X0:SortParameterDecl{}, X1:SortStorageDecl{}, X2:SortCodeDecl{})))), \or{SortContract{}} (\exists{SortContract{}} (X0:SortStorageDecl{}, \exists{SortContract{}} (X1:SortCodeDecl{}, \exists{SortContract{}} (X2:SortParameterDecl{}, Lbl'UndsSClnUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'StorageDecl'Unds'CodeDecl'Unds'ParameterDecl{}(X0:SortStorageDecl{}, X1:SortCodeDecl{}, X2:SortParameterDecl{})))), \or{SortContract{}} (\exists{SortContract{}} (X0:SortStorageDecl{}, \exists{SortContract{}} (X1:SortParameterDecl{}, \exists{SortContract{}} (X2:SortCodeDecl{}, Lbl'UndsSClnUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'StorageDecl'Unds'ParameterDecl'Unds'CodeDecl{}(X0:SortStorageDecl{}, X1:SortParameterDecl{}, X2:SortCodeDecl{})))), \bottom{SortContract{}}())))))))))))) [constructor{}()] // no junk + axiom{} \or{SortBinaryTypeName{}} (Lbllambda'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}(), \or{SortBinaryTypeName{}} (Lblor'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}(), \or{SortBinaryTypeName{}} (Lblpair'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}(), \or{SortBinaryTypeName{}} (\exists{SortBinaryTypeName{}} (Val:SortMapTypeName{}, inj{SortMapTypeName{}, SortBinaryTypeName{}} (Val:SortMapTypeName{})), \bottom{SortBinaryTypeName{}}())))) [constructor{}()] // no junk + axiom{} \or{SortEndianness{}} (LblbigEndianBytes{}(), \or{SortEndianness{}} (LbllittleEndianBytes{}(), \bottom{SortEndianness{}}())) [constructor{}()] // no junk + axiom{} \or{SortMichelsonTopCellFragment{}} (\exists{SortMichelsonTopCellFragment{}} (X0:SortParamtypeCellOpt{}, \exists{SortMichelsonTopCellFragment{}} (X1:SortParamvalueCellOpt{}, \exists{SortMichelsonTopCellFragment{}} (X2:SortStoragetypeCellOpt{}, \exists{SortMichelsonTopCellFragment{}} (X3:SortStoragevalueCellOpt{}, \exists{SortMichelsonTopCellFragment{}} (X4:SortMybalanceCellOpt{}, \exists{SortMichelsonTopCellFragment{}} (X5:SortMyamountCellOpt{}, \exists{SortMichelsonTopCellFragment{}} (X6:SortMynowCellOpt{}, \exists{SortMichelsonTopCellFragment{}} (X7:SortMyaddrCellOpt{}, \exists{SortMichelsonTopCellFragment{}} (X8:SortKnownaddrsCellOpt{}, \exists{SortMichelsonTopCellFragment{}} (X9:SortSourceaddrCellOpt{}, \exists{SortMichelsonTopCellFragment{}} (X10:SortSenderaddrCellOpt{}, \exists{SortMichelsonTopCellFragment{}} (X11:SortMychainidCellOpt{}, \exists{SortMichelsonTopCellFragment{}} (X12:SortNonceCellOpt{}, \exists{SortMichelsonTopCellFragment{}} (X13:SortBigmapsCellOpt{}, \exists{SortMichelsonTopCellFragment{}} (X14:SortScriptCellOpt{}, \exists{SortMichelsonTopCellFragment{}} (X15:SortKCellOpt{}, \exists{SortMichelsonTopCellFragment{}} (X16:SortStackCellOpt{}, \exists{SortMichelsonTopCellFragment{}} (X17:SortInputstackCellOpt{}, \exists{SortMichelsonTopCellFragment{}} (X18:SortExpectedCellOpt{}, \exists{SortMichelsonTopCellFragment{}} (X19:SortPreCellOpt{}, \exists{SortMichelsonTopCellFragment{}} (X20:SortPostCellOpt{}, \exists{SortMichelsonTopCellFragment{}} (X21:SortInvsCellOpt{}, \exists{SortMichelsonTopCellFragment{}} (X22:SortCutpointsCellOpt{}, \exists{SortMichelsonTopCellFragment{}} (X23:SortSymbolsCellOpt{}, \exists{SortMichelsonTopCellFragment{}} (X24:SortReturncodeCellOpt{}, \exists{SortMichelsonTopCellFragment{}} (X25:SortAssumeFailedCellOpt{}, \exists{SortMichelsonTopCellFragment{}} (X26:SortTraceCellOpt{}, Lbl'-LT-'michelsonTop'-GT-'-fragment{}(X0:SortParamtypeCellOpt{}, X1:SortParamvalueCellOpt{}, X2:SortStoragetypeCellOpt{}, X3:SortStoragevalueCellOpt{}, X4:SortMybalanceCellOpt{}, X5:SortMyamountCellOpt{}, X6:SortMynowCellOpt{}, X7:SortMyaddrCellOpt{}, X8:SortKnownaddrsCellOpt{}, X9:SortSourceaddrCellOpt{}, X10:SortSenderaddrCellOpt{}, X11:SortMychainidCellOpt{}, X12:SortNonceCellOpt{}, X13:SortBigmapsCellOpt{}, X14:SortScriptCellOpt{}, X15:SortKCellOpt{}, X16:SortStackCellOpt{}, X17:SortInputstackCellOpt{}, X18:SortExpectedCellOpt{}, X19:SortPreCellOpt{}, X20:SortPostCellOpt{}, X21:SortInvsCellOpt{}, X22:SortCutpointsCellOpt{}, X23:SortSymbolsCellOpt{}, X24:SortReturncodeCellOpt{}, X25:SortAssumeFailedCellOpt{}, X26:SortTraceCellOpt{})))))))))))))))))))))))))))), \bottom{SortMichelsonTopCellFragment{}}()) [constructor{}()] // no junk + axiom{} \or{SortNowGroup{}} (\exists{SortNowGroup{}} (X0:SortInt{}, Lblnow'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'NowGroup'Unds'Int{}(X0:SortInt{})), \bottom{SortNowGroup{}}()) [constructor{}()] // no junk + axiom{} \bottom{SortMap{}}() [constructor{}()] // no junk + axiom{} \or{SortMichelsonTopCell{}} (\exists{SortMichelsonTopCell{}} (X0:SortParamtypeCell{}, \exists{SortMichelsonTopCell{}} (X1:SortParamvalueCell{}, \exists{SortMichelsonTopCell{}} (X2:SortStoragetypeCell{}, \exists{SortMichelsonTopCell{}} (X3:SortStoragevalueCell{}, \exists{SortMichelsonTopCell{}} (X4:SortMybalanceCell{}, \exists{SortMichelsonTopCell{}} (X5:SortMyamountCell{}, \exists{SortMichelsonTopCell{}} (X6:SortMynowCell{}, \exists{SortMichelsonTopCell{}} (X7:SortMyaddrCell{}, \exists{SortMichelsonTopCell{}} (X8:SortKnownaddrsCell{}, \exists{SortMichelsonTopCell{}} (X9:SortSourceaddrCell{}, \exists{SortMichelsonTopCell{}} (X10:SortSenderaddrCell{}, \exists{SortMichelsonTopCell{}} (X11:SortMychainidCell{}, \exists{SortMichelsonTopCell{}} (X12:SortNonceCell{}, \exists{SortMichelsonTopCell{}} (X13:SortBigmapsCell{}, \exists{SortMichelsonTopCell{}} (X14:SortScriptCell{}, \exists{SortMichelsonTopCell{}} (X15:SortKCell{}, \exists{SortMichelsonTopCell{}} (X16:SortStackCell{}, \exists{SortMichelsonTopCell{}} (X17:SortInputstackCell{}, \exists{SortMichelsonTopCell{}} (X18:SortExpectedCell{}, \exists{SortMichelsonTopCell{}} (X19:SortPreCell{}, \exists{SortMichelsonTopCell{}} (X20:SortPostCell{}, \exists{SortMichelsonTopCell{}} (X21:SortInvsCell{}, \exists{SortMichelsonTopCell{}} (X22:SortCutpointsCell{}, \exists{SortMichelsonTopCell{}} (X23:SortSymbolsCell{}, \exists{SortMichelsonTopCell{}} (X24:SortReturncodeCell{}, \exists{SortMichelsonTopCell{}} (X25:SortAssumeFailedCell{}, \exists{SortMichelsonTopCell{}} (X26:SortTraceCell{}, Lbl'-LT-'michelsonTop'-GT-'{}(X0:SortParamtypeCell{}, X1:SortParamvalueCell{}, X2:SortStoragetypeCell{}, X3:SortStoragevalueCell{}, X4:SortMybalanceCell{}, X5:SortMyamountCell{}, X6:SortMynowCell{}, X7:SortMyaddrCell{}, X8:SortKnownaddrsCell{}, X9:SortSourceaddrCell{}, X10:SortSenderaddrCell{}, X11:SortMychainidCell{}, X12:SortNonceCell{}, X13:SortBigmapsCell{}, X14:SortScriptCell{}, X15:SortKCell{}, X16:SortStackCell{}, X17:SortInputstackCell{}, X18:SortExpectedCell{}, X19:SortPreCell{}, X20:SortPostCell{}, X21:SortInvsCell{}, X22:SortCutpointsCell{}, X23:SortSymbolsCell{}, X24:SortReturncodeCell{}, X25:SortAssumeFailedCell{}, X26:SortTraceCell{})))))))))))))))))))))))))))), \bottom{SortMichelsonTopCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortMapEntryList{}} (\exists{SortMapEntryList{}} (X0:SortMapEntry{}, \exists{SortMapEntryList{}} (X1:SortMapEntryList{}, Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'MapEntryList'Unds'MapEntry'Unds'MapEntryList{}(X0:SortMapEntry{}, X1:SortMapEntryList{}))), \or{SortMapEntryList{}} (\exists{SortMapEntryList{}} (Val:SortMapEntry{}, inj{SortMapEntry{}, SortMapEntryList{}} (Val:SortMapEntry{})), \bottom{SortMapEntryList{}}())) [constructor{}()] // no junk + axiom{} \or{SortReturncodeCell{}} (\exists{SortReturncodeCell{}} (X0:SortInt{}, Lbl'-LT-'returncode'-GT-'{}(X0:SortInt{})), \bottom{SortReturncodeCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortMyaddrCellOpt{}} (LblnoMyaddrCell{}(), \or{SortMyaddrCellOpt{}} (\exists{SortMyaddrCellOpt{}} (Val:SortMyaddrCell{}, inj{SortMyaddrCell{}, SortMyaddrCellOpt{}} (Val:SortMyaddrCell{})), \bottom{SortMyaddrCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortMapEntry{}} (\exists{SortMapEntry{}} (X0:SortData{}, \exists{SortMapEntry{}} (X1:SortData{}, LblElt'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'MapEntry'Unds'Data'Unds'Data{}(X0:SortData{}, X1:SortData{}))), \bottom{SortMapEntry{}}()) [constructor{}()] // no junk + axiom{} \or{SortInvariant{}} (\exists{SortInvariant{}} (X0:SortLiteralStack{}, \exists{SortInvariant{}} (X1:SortBlockList{}, Lbl'UndsLBraUndsRBraUnds'SYMBOLIC-UNIT-TEST-COMMON-SYNTAX'Unds'Invariant'Unds'LiteralStack'Unds'BlockList{}(X0:SortLiteralStack{}, X1:SortBlockList{}))), \bottom{SortInvariant{}}()) [constructor{}()] // no junk + axiom{} \or{SortStorageValueGroup{}} (\exists{SortStorageValueGroup{}} (X0:SortData{}, Lblstorage'Unds'value'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'StorageValueGroup'Unds'Data{}(X0:SortData{})), \bottom{SortStorageValueGroup{}}()) [constructor{}()] // no junk + axiom{} \or{SortAnnotationList{}} (Lbl'Stop'List'LBraQuotUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList'QuotRBraUnds'AnnotationList{}(), \or{SortAnnotationList{}} (\exists{SortAnnotationList{}} (X0:SortAnnotation{}, \exists{SortAnnotationList{}} (X1:SortAnnotationList{}, Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList{}(X0:SortAnnotation{}, X1:SortAnnotationList{}))), \bottom{SortAnnotationList{}}())) [constructor{}()] // no junk + axiom{} \or{SortStackElement{}} (\exists{SortStackElement{}} (X0:SortTypeName{}, \exists{SortStackElement{}} (X1:SortData{}, Lbl'LSqBUndsUndsRSqBUnds'MICHELSON-COMMON'Unds'StackElement'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}))), \bottom{SortStackElement{}}()) [constructor{}()] // no junk + axiom{} \or{SortInvariantsGroup{}} (\exists{SortInvariantsGroup{}} (X0:SortVariableAnnotation{}, \exists{SortInvariantsGroup{}} (X1:SortInvariant{}, Lblinvariant'UndsUndsUnds'SYMBOLIC-UNIT-TEST-COMMON-SYNTAX'Unds'InvariantsGroup'Unds'VariableAnnotation'Unds'Invariant{}(X0:SortVariableAnnotation{}, X1:SortInvariant{}))), \bottom{SortInvariantsGroup{}}()) [constructor{}()] // no junk + axiom{} \or{SortDataList{}} (\exists{SortDataList{}} (X0:SortData{}, \exists{SortDataList{}} (X1:SortDataList{}, Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'DataList'Unds'Data'Unds'DataList{}(X0:SortData{}, X1:SortDataList{}))), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortInstruction{}, inj{SortInstruction{}, SortDataList{}} (Val:SortInstruction{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortMapLiteral{}, inj{SortMapLiteral{}, SortDataList{}} (Val:SortMapLiteral{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortData{}, inj{SortData{}, SortDataList{}} (Val:SortData{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortList{}, inj{SortList{}, SortDataList{}} (Val:SortList{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortMBytesLiteral{}, inj{SortMBytesLiteral{}, SortDataList{}} (Val:SortMBytesLiteral{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortKey{}, inj{SortKey{}, SortDataList{}} (Val:SortKey{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortTypedData{}, inj{SortTypedData{}, SortDataList{}} (Val:SortTypedData{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortString{}, inj{SortString{}, SortDataList{}} (Val:SortString{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortTimestamp{}, inj{SortTimestamp{}, SortDataList{}} (Val:SortTimestamp{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortKeyHash{}, inj{SortKeyHash{}, SortDataList{}} (Val:SortKeyHash{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortBlockchainOperation{}, inj{SortBlockchainOperation{}, SortDataList{}} (Val:SortBlockchainOperation{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortContractData{}, inj{SortContractData{}, SortDataList{}} (Val:SortContractData{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortSimpleData{}, inj{SortSimpleData{}, SortDataList{}} (Val:SortSimpleData{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortMutez{}, inj{SortMutez{}, SortDataList{}} (Val:SortMutez{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortAddress{}, inj{SortAddress{}, SortDataList{}} (Val:SortAddress{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortSequenceData{}, inj{SortSequenceData{}, SortDataList{}} (Val:SortSequenceData{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortEmptyBlock{}, inj{SortEmptyBlock{}, SortDataList{}} (Val:SortEmptyBlock{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortBool{}, inj{SortBool{}, SortDataList{}} (Val:SortBool{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortOrData{}, inj{SortOrData{}, SortDataList{}} (Val:SortOrData{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortOptionData{}, inj{SortOptionData{}, SortDataList{}} (Val:SortOptionData{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortMap{}, inj{SortMap{}, SortDataList{}} (Val:SortMap{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortInt{}, inj{SortInt{}, SortDataList{}} (Val:SortInt{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortPair{}, inj{SortPair{}, SortDataList{}} (Val:SortPair{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortSignature{}, inj{SortSignature{}, SortDataList{}} (Val:SortSignature{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortLambdaData{}, inj{SortLambdaData{}, SortDataList{}} (Val:SortLambdaData{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortBlock{}, inj{SortBlock{}, SortDataList{}} (Val:SortBlock{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortSet{}, inj{SortSet{}, SortDataList{}} (Val:SortSet{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortChainId{}, inj{SortChainId{}, SortDataList{}} (Val:SortChainId{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortMBytes{}, inj{SortMBytes{}, SortDataList{}} (Val:SortMBytes{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortSymbolicData{}, inj{SortSymbolicData{}, SortDataList{}} (Val:SortSymbolicData{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortBytes{}, inj{SortBytes{}, SortDataList{}} (Val:SortBytes{})), \or{SortDataList{}} (\exists{SortDataList{}} (Val:SortFailedStack{}, inj{SortFailedStack{}, SortDataList{}} (Val:SortFailedStack{})), \bottom{SortDataList{}}()))))))))))))))))))))))))))))))))) [constructor{}()] // no junk + axiom{} \or{SortLiteralStack{}} (\exists{SortLiteralStack{}} (X0:SortStackElementList{}, Lbl'LBraUndsRBraUnds'UNIT-TEST-COMMON-SYNTAX'Unds'LiteralStack'Unds'StackElementList{}(X0:SortStackElementList{})), \bottom{SortLiteralStack{}}()) [constructor{}()] // no junk + axiom{} \or{SortOperationNonce{}} (\exists{SortOperationNonce{}} (X0:SortInt{}, Lbl'Hash'Nonce'LParUndsRParUnds'MICHELSON-COMMON'Unds'OperationNonce'Unds'Int{}(X0:SortInt{})), \bottom{SortOperationNonce{}}()) [constructor{}()] // no junk + axiom{} \or{SortStackCell{}} (\exists{SortStackCell{}} (X0:SortInternalStack{}, Lbl'-LT-'stack'-GT-'{}(X0:SortInternalStack{})), \bottom{SortStackCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortAnnotation{}} (\exists{SortAnnotation{}} (Val:SortTypeAnnotation{}, inj{SortTypeAnnotation{}, SortAnnotation{}} (Val:SortTypeAnnotation{})), \or{SortAnnotation{}} (\exists{SortAnnotation{}} (Val:SortFieldAnnotation{}, inj{SortFieldAnnotation{}, SortAnnotation{}} (Val:SortFieldAnnotation{})), \or{SortAnnotation{}} (\exists{SortAnnotation{}} (Val:SortVariableAnnotation{}, inj{SortVariableAnnotation{}, SortAnnotation{}} (Val:SortVariableAnnotation{})), \bottom{SortAnnotation{}}()))) [constructor{}()] // no junk + axiom{} \or{SortSelfGroup{}} (\exists{SortSelfGroup{}} (X0:SortString{}, Lblself'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'SelfGroup'Unds'String{}(X0:SortString{})), \bottom{SortSelfGroup{}}()) [constructor{}()] // no junk + axiom{} \or{SortUnifiedSet{}} (\exists{SortUnifiedSet{}} (Val:SortUnificationFailure{}, inj{SortUnificationFailure{}, SortUnifiedSet{}} (Val:SortUnificationFailure{})), \or{SortUnifiedSet{}} (\exists{SortUnifiedSet{}} (Val:SortSet{}, inj{SortSet{}, SortUnifiedSet{}} (Val:SortSet{})), \bottom{SortUnifiedSet{}}())) [constructor{}()] // no junk + axiom{} \or{SortMichelsonTopCellOpt{}} (LblnoMichelsonTopCell{}(), \or{SortMichelsonTopCellOpt{}} (\exists{SortMichelsonTopCellOpt{}} (Val:SortMichelsonTopCell{}, inj{SortMichelsonTopCell{}, SortMichelsonTopCellOpt{}} (Val:SortMichelsonTopCell{})), \bottom{SortMichelsonTopCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortKCellOpt{}} (LblnoKCell{}(), \or{SortKCellOpt{}} (\exists{SortKCellOpt{}} (Val:SortKCell{}, inj{SortKCell{}, SortKCellOpt{}} (Val:SortKCell{})), \bottom{SortKCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortStorageDecl{}} (\exists{SortStorageDecl{}} (X0:SortType{}, Lblstorage'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'StorageDecl'Unds'Type{}(X0:SortType{})), \bottom{SortStorageDecl{}}()) [constructor{}()] // no junk + axiom{} \or{SortGroup{}} (\exists{SortGroup{}} (Val:SortSourceGroup{}, inj{SortSourceGroup{}, SortGroup{}} (Val:SortSourceGroup{})), \or{SortGroup{}} (\exists{SortGroup{}} (Val:SortInputGroup{}, inj{SortInputGroup{}, SortGroup{}} (Val:SortInputGroup{})), \or{SortGroup{}} (\exists{SortGroup{}} (Val:SortBigMapGroup{}, inj{SortBigMapGroup{}, SortGroup{}} (Val:SortBigMapGroup{})), \or{SortGroup{}} (\exists{SortGroup{}} (Val:SortSenderGroup{}, inj{SortSenderGroup{}, SortGroup{}} (Val:SortSenderGroup{})), \or{SortGroup{}} (\exists{SortGroup{}} (Val:SortParameterValueGroup{}, inj{SortParameterValueGroup{}, SortGroup{}} (Val:SortParameterValueGroup{})), \or{SortGroup{}} (\exists{SortGroup{}} (Val:SortParameterDecl{}, inj{SortParameterDecl{}, SortGroup{}} (Val:SortParameterDecl{})), \or{SortGroup{}} (\exists{SortGroup{}} (Val:SortPreconditionGroup{}, inj{SortPreconditionGroup{}, SortGroup{}} (Val:SortPreconditionGroup{})), \or{SortGroup{}} (\exists{SortGroup{}} (Val:SortNowGroup{}, inj{SortNowGroup{}, SortGroup{}} (Val:SortNowGroup{})), \or{SortGroup{}} (\exists{SortGroup{}} (Val:SortStorageValueGroup{}, inj{SortStorageValueGroup{}, SortGroup{}} (Val:SortStorageValueGroup{})), \or{SortGroup{}} (\exists{SortGroup{}} (Val:SortInvariantsGroup{}, inj{SortInvariantsGroup{}, SortGroup{}} (Val:SortInvariantsGroup{})), \or{SortGroup{}} (\exists{SortGroup{}} (Val:SortSelfGroup{}, inj{SortSelfGroup{}, SortGroup{}} (Val:SortSelfGroup{})), \or{SortGroup{}} (\exists{SortGroup{}} (Val:SortStorageDecl{}, inj{SortStorageDecl{}, SortGroup{}} (Val:SortStorageDecl{})), \or{SortGroup{}} (\exists{SortGroup{}} (Val:SortParameterGroup{}, inj{SortParameterGroup{}, SortGroup{}} (Val:SortParameterGroup{})), \or{SortGroup{}} (\exists{SortGroup{}} (Val:SortOutputGroup{}, inj{SortOutputGroup{}, SortGroup{}} (Val:SortOutputGroup{})), \or{SortGroup{}} (\exists{SortGroup{}} (Val:SortCodeDecl{}, inj{SortCodeDecl{}, SortGroup{}} (Val:SortCodeDecl{})), \or{SortGroup{}} (\exists{SortGroup{}} (Val:SortBalanceGroup{}, inj{SortBalanceGroup{}, SortGroup{}} (Val:SortBalanceGroup{})), \or{SortGroup{}} (\exists{SortGroup{}} (Val:SortChainGroup{}, inj{SortChainGroup{}, SortGroup{}} (Val:SortChainGroup{})), \or{SortGroup{}} (\exists{SortGroup{}} (Val:SortContractGroup{}, inj{SortContractGroup{}, SortGroup{}} (Val:SortContractGroup{})), \or{SortGroup{}} (\exists{SortGroup{}} (Val:SortContractsGroup{}, inj{SortContractsGroup{}, SortGroup{}} (Val:SortContractsGroup{})), \or{SortGroup{}} (\exists{SortGroup{}} (Val:SortAmountGroup{}, inj{SortAmountGroup{}, SortGroup{}} (Val:SortAmountGroup{})), \or{SortGroup{}} (\exists{SortGroup{}} (Val:SortPostconditionGroup{}, inj{SortPostconditionGroup{}, SortGroup{}} (Val:SortPostconditionGroup{})), \or{SortGroup{}} (\exists{SortGroup{}} (Val:SortCodeGroup{}, inj{SortCodeGroup{}, SortGroup{}} (Val:SortCodeGroup{})), \bottom{SortGroup{}}())))))))))))))))))))))) [constructor{}()] // no junk + axiom{} \or{SortInvsCellOpt{}} (LblnoInvsCell{}(), \or{SortInvsCellOpt{}} (\exists{SortInvsCellOpt{}} (Val:SortInvsCell{}, inj{SortInvsCell{}, SortInvsCellOpt{}} (Val:SortInvsCell{})), \bottom{SortInvsCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortOtherContractsMapEntryList{}} (Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OtherContractsMapEntryList'Unds'OtherContractsMapEntry'Unds'OtherContractsMapEntryList'QuotRBraUnds'OtherContractsMapEntryList{}(), \or{SortOtherContractsMapEntryList{}} (\exists{SortOtherContractsMapEntryList{}} (X0:SortOtherContractsMapEntry{}, \exists{SortOtherContractsMapEntryList{}} (X1:SortOtherContractsMapEntryList{}, Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OtherContractsMapEntryList'Unds'OtherContractsMapEntry'Unds'OtherContractsMapEntryList{}(X0:SortOtherContractsMapEntry{}, X1:SortOtherContractsMapEntryList{}))), \bottom{SortOtherContractsMapEntryList{}}())) [constructor{}()] // no junk + axiom{} \or{SortStoragetypeCellOpt{}} (LblnoStoragetypeCell{}(), \or{SortStoragetypeCellOpt{}} (\exists{SortStoragetypeCellOpt{}} (Val:SortStoragetypeCell{}, inj{SortStoragetypeCell{}, SortStoragetypeCellOpt{}} (Val:SortStoragetypeCell{})), \bottom{SortStoragetypeCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortParameterGroup{}} (\exists{SortParameterGroup{}} (Val:SortParameterDecl{}, inj{SortParameterDecl{}, SortParameterGroup{}} (Val:SortParameterDecl{})), \bottom{SortParameterGroup{}}()) [constructor{}()] // no junk + axiom{} \or{SortInt{}} (\top{SortInt{}}(), \bottom{SortInt{}}()) [constructor{}()] // no junk (TODO: fix bug with \dv) + axiom{} \or{SortPair{}} (\exists{SortPair{}} (X0:SortData{}, \exists{SortPair{}} (X1:SortData{}, LblPair'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Pair'Unds'Data'Unds'Data{}(X0:SortData{}, X1:SortData{}))), \bottom{SortPair{}}()) [constructor{}()] // no junk + axiom{} \or{SortBigMapEntryList{}} (Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntryList'Unds'BigMapEntry'Unds'BigMapEntryList'QuotRBraUnds'BigMapEntryList{}(), \or{SortBigMapEntryList{}} (\exists{SortBigMapEntryList{}} (X0:SortBigMapEntry{}, \exists{SortBigMapEntryList{}} (X1:SortBigMapEntryList{}, Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntryList'Unds'BigMapEntry'Unds'BigMapEntryList{}(X0:SortBigMapEntry{}, X1:SortBigMapEntryList{}))), \bottom{SortBigMapEntryList{}}())) [constructor{}()] // no junk + axiom{} \or{SortOutputGroup{}} (\exists{SortOutputGroup{}} (X0:SortOutputStack{}, Lbloutput'UndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'OutputGroup'Unds'OutputStack{}(X0:SortOutputStack{})), \bottom{SortOutputGroup{}}()) [constructor{}()] // no junk + axiom{} \or{SortSignature{}} (\exists{SortSignature{}} (X0:SortString{}, Lbl'Hash'Signature'LParUndsRParUnds'MICHELSON-COMMON'Unds'Signature'Unds'String{}(X0:SortString{})), \bottom{SortSignature{}}()) [constructor{}()] // no junk + axiom{} \or{SortFloat{}} (\top{SortFloat{}}(), \bottom{SortFloat{}}()) [constructor{}()] // no junk (TODO: fix bug with \dv) + axiom{} \or{SortBigmapsCellOpt{}} (LblnoBigmapsCell{}(), \or{SortBigmapsCellOpt{}} (\exists{SortBigmapsCellOpt{}} (Val:SortBigmapsCell{}, inj{SortBigmapsCell{}, SortBigmapsCellOpt{}} (Val:SortBigmapsCell{})), \bottom{SortBigmapsCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortInputstackCell{}} (\exists{SortInputstackCell{}} (X0:SortK{}, Lbl'-LT-'inputstack'-GT-'{}(X0:SortK{})), \bottom{SortInputstackCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortCodeDecl{}} (\exists{SortCodeDecl{}} (X0:SortBlock{}, Lblcode'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'CodeDecl'Unds'Block{}(X0:SortBlock{})), \bottom{SortCodeDecl{}}()) [constructor{}()] // no junk + axiom{} \or{SortPreCellOpt{}} (LblnoPreCell{}(), \or{SortPreCellOpt{}} (\exists{SortPreCellOpt{}} (Val:SortPreCell{}, inj{SortPreCell{}, SortPreCellOpt{}} (Val:SortPreCell{})), \bottom{SortPreCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortLambdaData{}} (\exists{SortLambdaData{}} (X0:SortTypeName{}, \exists{SortLambdaData{}} (X1:SortTypeName{}, \exists{SortLambdaData{}} (X2:SortBlock{}, Lbl'Hash'Lambda'LParUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'LambdaData'Unds'TypeName'Unds'TypeName'Unds'Block{}(X0:SortTypeName{}, X1:SortTypeName{}, X2:SortBlock{})))), \bottom{SortLambdaData{}}()) [constructor{}()] // no junk + axiom{} \or{SortBalanceGroup{}} (\exists{SortBalanceGroup{}} (X0:SortInt{}, Lblbalance'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BalanceGroup'Unds'Int{}(X0:SortInt{})), \bottom{SortBalanceGroup{}}()) [constructor{}()] // no junk + axiom{} \or{SortInputstackCellOpt{}} (LblnoInputstackCell{}(), \or{SortInputstackCellOpt{}} (\exists{SortInputstackCellOpt{}} (Val:SortInputstackCell{}, inj{SortInputstackCell{}, SortInputstackCellOpt{}} (Val:SortInputstackCell{})), \bottom{SortInputstackCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortType{}} (Lbl'Hash'UnknownType'Unds'MICHELSON'Unds'Type{}(), \or{SortType{}} (\exists{SortType{}} (X0:SortNullaryTypeName{}, \exists{SortType{}} (X1:SortAnnotationList{}, Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(X0:SortNullaryTypeName{}, X1:SortAnnotationList{}))), \or{SortType{}} (\exists{SortType{}} (X0:SortUnaryTypeName{}, \exists{SortType{}} (X1:SortAnnotationList{}, \exists{SortType{}} (X2:SortType{}, Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(X0:SortUnaryTypeName{}, X1:SortAnnotationList{}, X2:SortType{})))), \or{SortType{}} (\exists{SortType{}} (X0:SortBinaryTypeName{}, \exists{SortType{}} (X1:SortAnnotationList{}, \exists{SortType{}} (X2:SortType{}, \exists{SortType{}} (X3:SortType{}, Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(X0:SortBinaryTypeName{}, X1:SortAnnotationList{}, X2:SortType{}, X3:SortType{}))))), \bottom{SortType{}}())))) [constructor{}()] // no junk + axiom{} \or{SortNumTypeName{}} (Lblint'Unds'MICHELSON-COMMON-SYNTAX'Unds'NumTypeName{}(), \or{SortNumTypeName{}} (Lblnat'Unds'MICHELSON-COMMON-SYNTAX'Unds'NumTypeName{}(), \bottom{SortNumTypeName{}}())) [constructor{}()] // no junk + axiom{} \or{SortGeneratedTopCell{}} (\exists{SortGeneratedTopCell{}} (X0:SortMichelsonTopCell{}, \exists{SortGeneratedTopCell{}} (X1:SortGeneratedCounterCell{}, Lbl'-LT-'generatedTop'-GT-'{}(X0:SortMichelsonTopCell{}, X1:SortGeneratedCounterCell{}))), \bottom{SortGeneratedTopCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortPgm{}} (\exists{SortPgm{}} (Val:SortSourceGroup{}, inj{SortSourceGroup{}, SortPgm{}} (Val:SortSourceGroup{})), \or{SortPgm{}} (\exists{SortPgm{}} (Val:SortInputGroup{}, inj{SortInputGroup{}, SortPgm{}} (Val:SortInputGroup{})), \or{SortPgm{}} (\exists{SortPgm{}} (Val:SortBigMapGroup{}, inj{SortBigMapGroup{}, SortPgm{}} (Val:SortBigMapGroup{})), \or{SortPgm{}} (\exists{SortPgm{}} (Val:SortSenderGroup{}, inj{SortSenderGroup{}, SortPgm{}} (Val:SortSenderGroup{})), \or{SortPgm{}} (\exists{SortPgm{}} (Val:SortGroups{}, inj{SortGroups{}, SortPgm{}} (Val:SortGroups{})), \or{SortPgm{}} (\exists{SortPgm{}} (Val:SortParameterValueGroup{}, inj{SortParameterValueGroup{}, SortPgm{}} (Val:SortParameterValueGroup{})), \or{SortPgm{}} (\exists{SortPgm{}} (Val:SortParameterDecl{}, inj{SortParameterDecl{}, SortPgm{}} (Val:SortParameterDecl{})), \or{SortPgm{}} (\exists{SortPgm{}} (Val:SortPreconditionGroup{}, inj{SortPreconditionGroup{}, SortPgm{}} (Val:SortPreconditionGroup{})), \or{SortPgm{}} (\exists{SortPgm{}} (Val:SortNowGroup{}, inj{SortNowGroup{}, SortPgm{}} (Val:SortNowGroup{})), \or{SortPgm{}} (\exists{SortPgm{}} (Val:SortStorageValueGroup{}, inj{SortStorageValueGroup{}, SortPgm{}} (Val:SortStorageValueGroup{})), \or{SortPgm{}} (\exists{SortPgm{}} (Val:SortInvariantsGroup{}, inj{SortInvariantsGroup{}, SortPgm{}} (Val:SortInvariantsGroup{})), \or{SortPgm{}} (\exists{SortPgm{}} (Val:SortSelfGroup{}, inj{SortSelfGroup{}, SortPgm{}} (Val:SortSelfGroup{})), \or{SortPgm{}} (\exists{SortPgm{}} (Val:SortStorageDecl{}, inj{SortStorageDecl{}, SortPgm{}} (Val:SortStorageDecl{})), \or{SortPgm{}} (\exists{SortPgm{}} (Val:SortGroup{}, inj{SortGroup{}, SortPgm{}} (Val:SortGroup{})), \or{SortPgm{}} (\exists{SortPgm{}} (Val:SortParameterGroup{}, inj{SortParameterGroup{}, SortPgm{}} (Val:SortParameterGroup{})), \or{SortPgm{}} (\exists{SortPgm{}} (Val:SortOutputGroup{}, inj{SortOutputGroup{}, SortPgm{}} (Val:SortOutputGroup{})), \or{SortPgm{}} (\exists{SortPgm{}} (Val:SortCodeDecl{}, inj{SortCodeDecl{}, SortPgm{}} (Val:SortCodeDecl{})), \or{SortPgm{}} (\exists{SortPgm{}} (Val:SortBalanceGroup{}, inj{SortBalanceGroup{}, SortPgm{}} (Val:SortBalanceGroup{})), \or{SortPgm{}} (\exists{SortPgm{}} (Val:SortChainGroup{}, inj{SortChainGroup{}, SortPgm{}} (Val:SortChainGroup{})), \or{SortPgm{}} (\exists{SortPgm{}} (Val:SortContractGroup{}, inj{SortContractGroup{}, SortPgm{}} (Val:SortContractGroup{})), \or{SortPgm{}} (\exists{SortPgm{}} (Val:SortContractsGroup{}, inj{SortContractsGroup{}, SortPgm{}} (Val:SortContractsGroup{})), \or{SortPgm{}} (\exists{SortPgm{}} (Val:SortAmountGroup{}, inj{SortAmountGroup{}, SortPgm{}} (Val:SortAmountGroup{})), \or{SortPgm{}} (\exists{SortPgm{}} (Val:SortPostconditionGroup{}, inj{SortPostconditionGroup{}, SortPgm{}} (Val:SortPostconditionGroup{})), \or{SortPgm{}} (\exists{SortPgm{}} (Val:SortCodeGroup{}, inj{SortCodeGroup{}, SortPgm{}} (Val:SortCodeGroup{})), \bottom{SortPgm{}}())))))))))))))))))))))))) [constructor{}()] // no junk + axiom{} \or{SortMynowCellOpt{}} (LblnoMynowCell{}(), \or{SortMynowCellOpt{}} (\exists{SortMynowCellOpt{}} (Val:SortMynowCell{}, inj{SortMynowCell{}, SortMynowCellOpt{}} (Val:SortMynowCell{})), \bottom{SortMynowCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortBlock{}} (\exists{SortBlock{}} (X0:SortDataList{}, Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Block'Unds'DataList{}(X0:SortDataList{})), \or{SortBlock{}} (\exists{SortBlock{}} (Val:SortEmptyBlock{}, inj{SortEmptyBlock{}, SortBlock{}} (Val:SortEmptyBlock{})), \bottom{SortBlock{}}())) [constructor{}()] // no junk + axiom{} \or{SortChainGroup{}} (\exists{SortChainGroup{}} (X0:SortMBytes{}, Lblchain'Unds'id'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'ChainGroup'Unds'MBytes{}(X0:SortMBytes{})), \bottom{SortChainGroup{}}()) [constructor{}()] // no junk + axiom{} \or{SortBigmapsCell{}} (\exists{SortBigmapsCell{}} (X0:SortMap{}, Lbl'-LT-'bigmaps'-GT-'{}(X0:SortMap{})), \bottom{SortBigmapsCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortInvsCell{}} (\exists{SortInvsCell{}} (X0:SortMap{}, Lbl'-LT-'invs'-GT-'{}(X0:SortMap{})), \bottom{SortInvsCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortKnownaddrsCellOpt{}} (LblnoKnownaddrsCell{}(), \or{SortKnownaddrsCellOpt{}} (\exists{SortKnownaddrsCellOpt{}} (Val:SortKnownaddrsCell{}, inj{SortKnownaddrsCell{}, SortKnownaddrsCellOpt{}} (Val:SortKnownaddrsCell{})), \bottom{SortKnownaddrsCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortMychainidCellOpt{}} (LblnoMychainidCell{}(), \or{SortMychainidCellOpt{}} (\exists{SortMychainidCellOpt{}} (Val:SortMychainidCell{}, inj{SortMychainidCell{}, SortMychainidCellOpt{}} (Val:SortMychainidCell{})), \bottom{SortMychainidCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortMapOpInfo{}} (\exists{SortMapOpInfo{}} (X0:SortTypeName{}, \exists{SortMapOpInfo{}} (X1:SortTypeName{}, \exists{SortMapOpInfo{}} (X2:SortMaybeTypeName{}, \exists{SortMapOpInfo{}} (X3:SortMap{}, \exists{SortMapOpInfo{}} (X4:SortMap{}, \exists{SortMapOpInfo{}} (X5:SortBlock{}, Lbl'Hash'MapOpInfo'LParUndsCommUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'MapOpInfo'Unds'TypeName'Unds'TypeName'Unds'MaybeTypeName'Unds'Map'Unds'Map'Unds'Block{}(X0:SortTypeName{}, X1:SortTypeName{}, X2:SortMaybeTypeName{}, X3:SortMap{}, X4:SortMap{}, X5:SortBlock{}))))))), \bottom{SortMapOpInfo{}}()) [constructor{}()] // no junk + axiom{} \or{SortAssumeFailedCellOpt{}} (LblnoAssumeFailedCell{}(), \or{SortAssumeFailedCellOpt{}} (\exists{SortAssumeFailedCellOpt{}} (Val:SortAssumeFailedCell{}, inj{SortAssumeFailedCell{}, SortAssumeFailedCellOpt{}} (Val:SortAssumeFailedCell{})), \bottom{SortAssumeFailedCellOpt{}}())) [constructor{}()] // no junk + axiom{} \bottom{SortSet{}}() [constructor{}()] // no junk + axiom{} \or{SortInternalStack{}} (\exists{SortInternalStack{}} (Val:SortStack{}, inj{SortStack{}, SortInternalStack{}} (Val:SortStack{})), \or{SortInternalStack{}} (\exists{SortInternalStack{}} (Val:SortFailedStack{}, inj{SortFailedStack{}, SortInternalStack{}} (Val:SortFailedStack{})), \bottom{SortInternalStack{}}())) [constructor{}()] // no junk + axiom{} \or{SortChainId{}} (\exists{SortChainId{}} (X0:SortMBytes{}, Lbl'Hash'ChainId'LParUndsRParUnds'MICHELSON-COMMON'Unds'ChainId'Unds'MBytes{}(X0:SortMBytes{})), \bottom{SortChainId{}}()) [constructor{}()] // no junk + axiom{} \or{SortContractGroup{}} (\exists{SortContractGroup{}} (X0:SortContract{}, Lblcontract'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'ContractGroup'Unds'Contract{}(X0:SortContract{})), \bottom{SortContractGroup{}}()) [constructor{}()] // no junk + axiom{} \or{SortNonceCell{}} (\exists{SortNonceCell{}} (X0:SortOperationNonce{}, Lbl'-LT-'nonce'-GT-'{}(X0:SortOperationNonce{})), \bottom{SortNonceCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortMBytes{}} (\exists{SortMBytes{}} (X0:SortMBytes{}, Lbl'Hash'Blake2B'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(X0:SortMBytes{})), \or{SortMBytes{}} (\exists{SortMBytes{}} (X0:SortTypeName{}, \exists{SortMBytes{}} (X1:SortData{}, Lbl'Hash'Packed'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'TypeName'Unds'Data{}(X0:SortTypeName{}, X1:SortData{}))), \or{SortMBytes{}} (\exists{SortMBytes{}} (X0:SortMBytes{}, Lbl'Hash'SHA256'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(X0:SortMBytes{})), \or{SortMBytes{}} (\exists{SortMBytes{}} (X0:SortMBytes{}, Lbl'Hash'SHA512'LParUndsRParUnds'MICHELSON-COMMON'Unds'MBytes'Unds'MBytes{}(X0:SortMBytes{})), \or{SortMBytes{}} (\exists{SortMBytes{}} (X0:SortKey{}, \exists{SortMBytes{}} (X1:SortSignature{}, \exists{SortMBytes{}} (X2:SortMBytes{}, Lbl'Hash'SignedMBytes'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'MBytes'Unds'Key'Unds'Signature'Unds'MBytes{}(X0:SortKey{}, X1:SortSignature{}, X2:SortMBytes{})))), \or{SortMBytes{}} (\exists{SortMBytes{}} (Val:SortMBytesLiteral{}, inj{SortMBytesLiteral{}, SortMBytes{}} (Val:SortMBytesLiteral{})), \or{SortMBytes{}} (\exists{SortMBytes{}} (Val:SortBytes{}, inj{SortBytes{}, SortMBytes{}} (Val:SortBytes{})), \bottom{SortMBytes{}}()))))))) [constructor{}()] // no junk + axiom{} \or{SortOutputStack{}} (\exists{SortOutputStack{}} (Val:SortLiteralStack{}, inj{SortLiteralStack{}, SortOutputStack{}} (Val:SortLiteralStack{})), \or{SortOutputStack{}} (\exists{SortOutputStack{}} (Val:SortFailedStack{}, inj{SortFailedStack{}, SortOutputStack{}} (Val:SortFailedStack{})), \bottom{SortOutputStack{}}())) [constructor{}()] // no junk + axiom{} \or{SortFieldAnnotation{}} (\top{SortFieldAnnotation{}}(), \bottom{SortFieldAnnotation{}}()) [constructor{}()] // no junk (TODO: fix bug with \dv) + axiom{} \or{SortContractsGroup{}} (\exists{SortContractsGroup{}} (X0:SortOtherContractsMapEntryList{}, Lblother'Unds'contracts'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'ContractsGroup'Unds'OtherContractsMapEntryList{}(X0:SortOtherContractsMapEntryList{})), \bottom{SortContractsGroup{}}()) [constructor{}()] // no junk + axiom{} \or{SortIOString{}} (\exists{SortIOString{}} (Val:SortString{}, inj{SortString{}, SortIOString{}} (Val:SortString{})), \or{SortIOString{}} (\exists{SortIOString{}} (Val:SortIOError{}, inj{SortIOError{}, SortIOString{}} (Val:SortIOError{})), \bottom{SortIOString{}}())) [constructor{}()] // no junk + axiom{} \or{SortStoragevalueCell{}} (\exists{SortStoragevalueCell{}} (X0:SortPreData{}, Lbl'-LT-'storagevalue'-GT-'{}(X0:SortPreData{})), \bottom{SortStoragevalueCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortSymbolicData{}} (\top{SortSymbolicData{}}(), \bottom{SortSymbolicData{}}()) [constructor{}()] // no junk (TODO: fix bug with \dv) + axiom{} \or{SortParamtypeCell{}} (\exists{SortParamtypeCell{}} (X0:SortPreType{}, Lbl'-LT-'paramtype'-GT-'{}(X0:SortPreType{})), \bottom{SortParamtypeCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortSymbolsCellOpt{}} (LblnoSymbolsCell{}(), \or{SortSymbolsCellOpt{}} (\exists{SortSymbolsCellOpt{}} (Val:SortSymbolsCell{}, inj{SortSymbolsCell{}, SortSymbolsCellOpt{}} (Val:SortSymbolsCell{})), \bottom{SortSymbolsCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortVariableAnnotation{}} (\top{SortVariableAnnotation{}}(), \bottom{SortVariableAnnotation{}}()) [constructor{}()] // no junk (TODO: fix bug with \dv) + axiom{} \or{SortGeneratedTopCellFragment{}} (\exists{SortGeneratedTopCellFragment{}} (X0:SortMichelsonTopCellOpt{}, \exists{SortGeneratedTopCellFragment{}} (X1:SortGeneratedCounterCellOpt{}, Lbl'-LT-'generatedTop'-GT-'-fragment{}(X0:SortMichelsonTopCellOpt{}, X1:SortGeneratedCounterCellOpt{}))), \bottom{SortGeneratedTopCellFragment{}}()) [constructor{}()] // no junk + axiom{} \or{SortMapTypeName{}} (Lblbig'Unds'map'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}(), \or{SortMapTypeName{}} (Lblmap'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}(), \bottom{SortMapTypeName{}}())) [constructor{}()] // no junk + axiom{} \or{SortBlockList{}} (Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockList'Unds'Block'Unds'BlockList'QuotRBraUnds'BlockList{}(), \or{SortBlockList{}} (\exists{SortBlockList{}} (X0:SortBlock{}, \exists{SortBlockList{}} (X1:SortBlockList{}, Lbl'UndsSClnUndsUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockList'Unds'Block'Unds'BlockList{}(X0:SortBlock{}, X1:SortBlockList{}))), \bottom{SortBlockList{}}())) [constructor{}()] // no junk + axiom{} \or{SortReturncodeCellOpt{}} (LblnoReturncodeCell{}(), \or{SortReturncodeCellOpt{}} (\exists{SortReturncodeCellOpt{}} (Val:SortReturncodeCell{}, inj{SortReturncodeCell{}, SortReturncodeCellOpt{}} (Val:SortReturncodeCell{})), \bottom{SortReturncodeCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortIOError{}} (Lbl'Hash'E2BIG{}(), \or{SortIOError{}} (Lbl'Hash'EACCES{}(), \or{SortIOError{}} (Lbl'Hash'EADDRINUSE{}(), \or{SortIOError{}} (Lbl'Hash'EADDRNOTAVAIL{}(), \or{SortIOError{}} (Lbl'Hash'EAFNOSUPPORT{}(), \or{SortIOError{}} (Lbl'Hash'EAGAIN{}(), \or{SortIOError{}} (Lbl'Hash'EALREADY{}(), \or{SortIOError{}} (Lbl'Hash'EBADF{}(), \or{SortIOError{}} (Lbl'Hash'EBUSY{}(), \or{SortIOError{}} (Lbl'Hash'ECHILD{}(), \or{SortIOError{}} (Lbl'Hash'ECONNABORTED{}(), \or{SortIOError{}} (Lbl'Hash'ECONNREFUSED{}(), \or{SortIOError{}} (Lbl'Hash'ECONNRESET{}(), \or{SortIOError{}} (Lbl'Hash'EDEADLK{}(), \or{SortIOError{}} (Lbl'Hash'EDESTADDRREQ{}(), \or{SortIOError{}} (Lbl'Hash'EDOM{}(), \or{SortIOError{}} (Lbl'Hash'EEXIST{}(), \or{SortIOError{}} (Lbl'Hash'EFAULT{}(), \or{SortIOError{}} (Lbl'Hash'EFBIG{}(), \or{SortIOError{}} (Lbl'Hash'EHOSTDOWN{}(), \or{SortIOError{}} (Lbl'Hash'EHOSTUNREACH{}(), \or{SortIOError{}} (Lbl'Hash'EINPROGRESS{}(), \or{SortIOError{}} (Lbl'Hash'EINTR{}(), \or{SortIOError{}} (Lbl'Hash'EINVAL{}(), \or{SortIOError{}} (Lbl'Hash'EIO{}(), \or{SortIOError{}} (Lbl'Hash'EISCONN{}(), \or{SortIOError{}} (Lbl'Hash'EISDIR{}(), \or{SortIOError{}} (Lbl'Hash'ELOOP{}(), \or{SortIOError{}} (Lbl'Hash'EMFILE{}(), \or{SortIOError{}} (Lbl'Hash'EMLINK{}(), \or{SortIOError{}} (Lbl'Hash'EMSGSIZE{}(), \or{SortIOError{}} (Lbl'Hash'ENAMETOOLONG{}(), \or{SortIOError{}} (Lbl'Hash'ENETDOWN{}(), \or{SortIOError{}} (Lbl'Hash'ENETRESET{}(), \or{SortIOError{}} (Lbl'Hash'ENETUNREACH{}(), \or{SortIOError{}} (Lbl'Hash'ENFILE{}(), \or{SortIOError{}} (Lbl'Hash'ENOBUFS{}(), \or{SortIOError{}} (Lbl'Hash'ENODEV{}(), \or{SortIOError{}} (Lbl'Hash'ENOENT{}(), \or{SortIOError{}} (Lbl'Hash'ENOEXEC{}(), \or{SortIOError{}} (Lbl'Hash'ENOLCK{}(), \or{SortIOError{}} (Lbl'Hash'ENOMEM{}(), \or{SortIOError{}} (Lbl'Hash'ENOPROTOOPT{}(), \or{SortIOError{}} (Lbl'Hash'ENOSPC{}(), \or{SortIOError{}} (Lbl'Hash'ENOSYS{}(), \or{SortIOError{}} (Lbl'Hash'ENOTCONN{}(), \or{SortIOError{}} (Lbl'Hash'ENOTDIR{}(), \or{SortIOError{}} (Lbl'Hash'ENOTEMPTY{}(), \or{SortIOError{}} (Lbl'Hash'ENOTSOCK{}(), \or{SortIOError{}} (Lbl'Hash'ENOTTY{}(), \or{SortIOError{}} (Lbl'Hash'ENXIO{}(), \or{SortIOError{}} (Lbl'Hash'EOF{}(), \or{SortIOError{}} (Lbl'Hash'EOPNOTSUPP{}(), \or{SortIOError{}} (Lbl'Hash'EOVERFLOW{}(), \or{SortIOError{}} (Lbl'Hash'EPERM{}(), \or{SortIOError{}} (Lbl'Hash'EPFNOSUPPORT{}(), \or{SortIOError{}} (Lbl'Hash'EPIPE{}(), \or{SortIOError{}} (Lbl'Hash'EPROTONOSUPPORT{}(), \or{SortIOError{}} (Lbl'Hash'EPROTOTYPE{}(), \or{SortIOError{}} (Lbl'Hash'ERANGE{}(), \or{SortIOError{}} (Lbl'Hash'EROFS{}(), \or{SortIOError{}} (Lbl'Hash'ESHUTDOWN{}(), \or{SortIOError{}} (Lbl'Hash'ESOCKTNOSUPPORT{}(), \or{SortIOError{}} (Lbl'Hash'ESPIPE{}(), \or{SortIOError{}} (Lbl'Hash'ESRCH{}(), \or{SortIOError{}} (Lbl'Hash'ETIMEDOUT{}(), \or{SortIOError{}} (Lbl'Hash'ETOOMANYREFS{}(), \or{SortIOError{}} (Lbl'Hash'EWOULDBLOCK{}(), \or{SortIOError{}} (Lbl'Hash'EXDEV{}(), \or{SortIOError{}} (\exists{SortIOError{}} (X0:SortInt{}, Lbl'Hash'unknownIOError{}(X0:SortInt{})), \bottom{SortIOError{}}())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) [constructor{}()] // no junk + axiom{} \or{SortBytes{}} (\top{SortBytes{}}(), \bottom{SortBytes{}}()) [constructor{}()] // no junk (TODO: fix bug with \dv) + axiom{} \or{SortAssumeFailedCell{}} (\exists{SortAssumeFailedCell{}} (X0:SortBool{}, Lbl'-LT-'assumeFailed'-GT-'{}(X0:SortBool{})), \bottom{SortAssumeFailedCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortSenderaddrCell{}} (\exists{SortSenderaddrCell{}} (X0:SortAddress{}, Lbl'-LT-'senderaddr'-GT-'{}(X0:SortAddress{})), \bottom{SortSenderaddrCell{}}()) [constructor{}()] // no junk + axiom{} \or{SortAmountGroup{}} (\exists{SortAmountGroup{}} (X0:SortInt{}, Lblamount'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AmountGroup'Unds'Int{}(X0:SortInt{})), \bottom{SortAmountGroup{}}()) [constructor{}()] // no junk + axiom{} \or{SortPostconditionGroup{}} (\exists{SortPostconditionGroup{}} (X0:SortBlockList{}, Lblpostcondition'LBraUndsRBraUnds'SYMBOLIC-UNIT-TEST-COMMON-SYNTAX'Unds'PostconditionGroup'Unds'BlockList{}(X0:SortBlockList{})), \bottom{SortPostconditionGroup{}}()) [constructor{}()] // no junk + axiom{} \or{SortFailedStack{}} (\exists{SortFailedStack{}} (X0:SortData{}, Lbl'LPar'Failed'UndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Data{}(X0:SortData{})), \or{SortFailedStack{}} (\exists{SortFailedStack{}} (X0:SortInt{}, \exists{SortFailedStack{}} (X1:SortInt{}, Lbl'LPar'GeneralOverflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(X0:SortInt{}, X1:SortInt{}))), \or{SortFailedStack{}} (\exists{SortFailedStack{}} (X0:SortInt{}, \exists{SortFailedStack{}} (X1:SortInt{}, Lbl'LPar'MutezOverflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(X0:SortInt{}, X1:SortInt{}))), \or{SortFailedStack{}} (\exists{SortFailedStack{}} (X0:SortInt{}, \exists{SortFailedStack{}} (X1:SortInt{}, Lbl'LPar'MutezUnderflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(X0:SortInt{}, X1:SortInt{}))), \bottom{SortFailedStack{}}())))) [constructor{}()] // no junk + axiom{} \or{SortPostCellOpt{}} (LblnoPostCell{}(), \or{SortPostCellOpt{}} (\exists{SortPostCellOpt{}} (Val:SortPostCell{}, inj{SortPostCell{}, SortPostCellOpt{}} (Val:SortPostCell{})), \bottom{SortPostCellOpt{}}())) [constructor{}()] // no junk + axiom{} \or{SortCodeGroup{}} (\exists{SortCodeGroup{}} (Val:SortCodeDecl{}, inj{SortCodeDecl{}, SortCodeGroup{}} (Val:SortCodeDecl{})), \bottom{SortCodeGroup{}}()) [constructor{}()] // no junk + +// rules +// rule ``(``(_0,_1,_2,_3,_4,_5,_6,_7,``(KnownAddrs) #as _26,_8,_9,_10,_11,``(BigMaps) #as _27,_12,``(`#Bind(_,_)_MICHELSON_KItem_InternalStack_InternalStack`(inj{Stack,InternalStack}(`_;__MICHELSON-COMMON_Stack_StackElement_Stack`(`[__]_MICHELSON-COMMON_StackElement_TypeName_Data`(T,ED),SS)),inj{Stack,InternalStack}(`_;__MICHELSON-COMMON_Stack_StackElement_Stack`(`[__]_MICHELSON-COMMON_StackElement_TypeName_Data`(T,AD),SS')))~>_DotVar2),_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23),_DotVar0) #as #Configuration=>``(``(_0,_1,_2,_3,_4,_5,_6,_7,_26,_8,_9,_10,_11,_27,_12,``(`#Bind(_,_)_MICHELSON_KItem_InternalStack_InternalStack`(inj{Stack,InternalStack}(SS),inj{Stack,InternalStack}(SS'))~>_DotVar2),_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23),_DotVar0) requires `#ConcreteMatch(_,_,_,_,_)_MICHELSON_Bool_Data_Type_Map_Map_Data`(ED,`#Type(_)_MICHELSON-COMMON_Type_TypeName`(T),KnownAddrs,BigMaps,AD,#Configuration) ensures #token("true","Bool") [UNIQUE_ID(0f2afc8640e95c8ca82185283e014fae4219114900e1e98a81539980ea595c83), contentStartColumn(8), contentStartLine(2097), org.kframework.attributes.Location(Location(2091,8,2098,67)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol])] + alias rule0LHS{}(SortGeneratedTopCell{},SortData{},SortMap{},SortData{},SortMap{},SortStack{},SortStack{},SortTypeName{},SortParamtypeCell{},SortParamvalueCell{},SortMychainidCell{},SortNonceCell{},SortScriptCell{},SortStackCell{},SortInputstackCell{},SortExpectedCell{},SortPreCell{},SortPostCell{},SortInvsCell{},SortCutpointsCell{},SortStoragetypeCell{},SortSymbolsCell{},SortReturncodeCell{},SortAssumeFailedCell{},SortTraceCell{},SortKnownaddrsCell{},SortBigmapsCell{},SortStoragevalueCell{},SortMybalanceCell{},SortMyamountCell{},SortMynowCell{},SortMyaddrCell{},SortSourceaddrCell{},SortSenderaddrCell{},SortGeneratedCounterCell{},SortK{}) : SortGeneratedTopCell{} + where rule0LHS{}(Var'Hash'Configuration:SortGeneratedTopCell{},VarAD:SortData{},VarBigMaps:SortMap{},VarED:SortData{},VarKnownAddrs:SortMap{},VarSS:SortStack{},VarSS'Apos':SortStack{},VarT:SortTypeName{},Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortScriptCell{},Var'Unds'13:SortStackCell{},Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{},Var'Unds'26:SortKnownaddrsCell{},Var'Unds'27:SortBigmapsCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}) := + \and{SortGeneratedTopCell{}} ( + \equals{SortBool{},SortGeneratedTopCell{}}( + Lbl'Hash'ConcreteMatch'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Bool'Unds'Data'Unds'Type'Unds'Map'Unds'Map'Unds'Data{}(VarED:SortData{},Lbl'Hash'Type'LParUndsRParUnds'MICHELSON-COMMON'Unds'Type'Unds'TypeName{}(VarT:SortTypeName{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},VarAD:SortData{},Var'Hash'Configuration:SortGeneratedTopCell{}), + \dv{SortBool{}}("true")), \and{SortGeneratedTopCell{}}(Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},\and{SortKnownaddrsCell{}}(Lbl'-LT-'knownaddrs'-GT-'{}(VarKnownAddrs:SortMap{}),Var'Unds'26:SortKnownaddrsCell{}),Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},\and{SortBigmapsCell{}}(Lbl'-LT-'bigmaps'-GT-'{}(VarBigMaps:SortMap{}),Var'Unds'27:SortBigmapsCell{}),Var'Unds'12:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(kseq{}(Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(inj{SortStack{}, SortInternalStack{}}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack{}(Lbl'LSqBUndsUndsRSqBUnds'MICHELSON-COMMON'Unds'StackElement'Unds'TypeName'Unds'Data{}(VarT:SortTypeName{},VarED:SortData{}),VarSS:SortStack{})),inj{SortStack{}, SortInternalStack{}}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack{}(Lbl'LSqBUndsUndsRSqBUnds'MICHELSON-COMMON'Unds'StackElement'Unds'TypeName'Unds'Data{}(VarT:SortTypeName{},VarAD:SortData{}),VarSS'Apos':SortStack{}))),Var'Unds'DotVar2:SortK{})),Var'Unds'13:SortStackCell{},Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{}),Var'Hash'Configuration:SortGeneratedTopCell{})) [] + + axiom{} \rewrites{SortGeneratedTopCell{}} ( + rule0LHS{}(Var'Hash'Configuration:SortGeneratedTopCell{},VarAD:SortData{},VarBigMaps:SortMap{},VarED:SortData{},VarKnownAddrs:SortMap{},VarSS:SortStack{},VarSS'Apos':SortStack{},VarT:SortTypeName{},Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortScriptCell{},Var'Unds'13:SortStackCell{},Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{},Var'Unds'26:SortKnownaddrsCell{},Var'Unds'27:SortBigmapsCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}), + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},Var'Unds'26:SortKnownaddrsCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'27:SortBigmapsCell{},Var'Unds'12:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(kseq{}(Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(inj{SortStack{}, SortInternalStack{}}(VarSS:SortStack{}),inj{SortStack{}, SortInternalStack{}}(VarSS'Apos':SortStack{})),Var'Unds'DotVar2:SortK{})),Var'Unds'13:SortStackCell{},Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{}))) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("2097"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2091,8,2098,67)"), UNIQUE'Unds'ID{}("0f2afc8640e95c8ca82185283e014fae4219114900e1e98a81539980ea595c83")] + +// rule ``(``(_0,_1,_2,_3,_4,_5,_6,_7,``(KnownAddrs) #as _26,_8,_9,_10,_11,``(BigMaps),_12,``(`#ConvertBigMapsToNative_MICHELSON_KItem`(.KList)~>_DotVar2),_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23),_DotVar0) #as #Configuration=>``(``(_0,_1,_2,_3,_4,_5,_6,_7,_26,_8,_9,_10,_11,``(`#ConvertBigMapsToNative(_)_MICHELSON_Map_Map`(BigMaps,#Configuration)),_12,``(_DotVar2),_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23),_DotVar0) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(02aaf6dbcf01dfbca7ba62c61bc365baed7dd3f61f1df811d08fbbba8fa7fc73), contentStartColumn(8), contentStartLine(517), org.kframework.attributes.Location(Location(517,8,519,72)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + alias rule1LHS{}(SortGeneratedTopCell{},SortMap{},SortMap{},SortParamtypeCell{},SortParamvalueCell{},SortMychainidCell{},SortNonceCell{},SortScriptCell{},SortStackCell{},SortInputstackCell{},SortExpectedCell{},SortPreCell{},SortPostCell{},SortInvsCell{},SortCutpointsCell{},SortStoragetypeCell{},SortSymbolsCell{},SortReturncodeCell{},SortAssumeFailedCell{},SortTraceCell{},SortKnownaddrsCell{},SortStoragevalueCell{},SortMybalanceCell{},SortMyamountCell{},SortMynowCell{},SortMyaddrCell{},SortSourceaddrCell{},SortSenderaddrCell{},SortGeneratedCounterCell{},SortK{}) : SortGeneratedTopCell{} + where rule1LHS{}(Var'Hash'Configuration:SortGeneratedTopCell{},VarBigMaps:SortMap{},VarKnownAddrs:SortMap{},Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortScriptCell{},Var'Unds'13:SortStackCell{},Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{},Var'Unds'26:SortKnownaddrsCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}) := + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), \and{SortGeneratedTopCell{}}(Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},\and{SortKnownaddrsCell{}}(Lbl'-LT-'knownaddrs'-GT-'{}(VarKnownAddrs:SortMap{}),Var'Unds'26:SortKnownaddrsCell{}),Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Lbl'-LT-'bigmaps'-GT-'{}(VarBigMaps:SortMap{}),Var'Unds'12:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(kseq{}(Lbl'Hash'ConvertBigMapsToNative'Unds'MICHELSON'Unds'KItem{}(),Var'Unds'DotVar2:SortK{})),Var'Unds'13:SortStackCell{},Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{}),Var'Hash'Configuration:SortGeneratedTopCell{})) [] + + axiom{} \rewrites{SortGeneratedTopCell{}} ( + rule1LHS{}(Var'Hash'Configuration:SortGeneratedTopCell{},VarBigMaps:SortMap{},VarKnownAddrs:SortMap{},Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortScriptCell{},Var'Unds'13:SortStackCell{},Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{},Var'Unds'26:SortKnownaddrsCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}), + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},Var'Unds'26:SortKnownaddrsCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Lbl'-LT-'bigmaps'-GT-'{}(Lbl'Hash'ConvertBigMapsToNative'LParUndsRParUnds'MICHELSON'Unds'Map'Unds'Map{}(VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{})),Var'Unds'12:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(Var'Unds'DotVar2:SortK{}),Var'Unds'13:SortStackCell{},Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{}))) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("517"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(517,8,519,72)"), UNIQUE'Unds'ID{}("02aaf6dbcf01dfbca7ba62c61bc365baed7dd3f61f1df811d08fbbba8fa7fc73")] + +// rule ``(``(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,``(inj{Instruction,KItem}(`PUSH____MICHELSON-COMMON-SYNTAX_Instruction_AnnotationList_Type_Data`(A,T,X))~>_DotVar2),_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25),_DotVar0) #as #Configuration=>``(``(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,``(inj{Instruction,KItem}(`PUSH____MICHELSON-COMMON-SYNTAX_Instruction_AnnotationList_Type_Data`(A,T,`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Data,DataOrSeq}(X),T,`.Map`(.KList),`.Map`(.KList),#Configuration)))~>_DotVar2),_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25),_DotVar0) requires `_andBool_`(`notBool_`(`isValue(_)_MICHELSON_Bool_Data`(X)),`notBool_`(isSymbolicData(inj{Data,KItem}(X)))) ensures #token("true","Bool") [UNIQUE_ID(3b3b1ed65e9f379b9dfcd32d848f052e2e735adeff3bc281648b20c3b0817c33), contentStartColumn(8), contentStartLine(885), org.kframework.attributes.Location(Location(885,8,887,39)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol])] + alias rule2LHS{}(SortGeneratedTopCell{},SortAnnotationList{},SortType{},SortData{},SortParamtypeCell{},SortParamvalueCell{},SortSenderaddrCell{},SortMychainidCell{},SortNonceCell{},SortBigmapsCell{},SortScriptCell{},SortStackCell{},SortInputstackCell{},SortExpectedCell{},SortPreCell{},SortPostCell{},SortStoragetypeCell{},SortInvsCell{},SortCutpointsCell{},SortSymbolsCell{},SortReturncodeCell{},SortAssumeFailedCell{},SortTraceCell{},SortStoragevalueCell{},SortMybalanceCell{},SortMyamountCell{},SortMynowCell{},SortMyaddrCell{},SortKnownaddrsCell{},SortSourceaddrCell{},SortGeneratedCounterCell{},SortK{}) : SortGeneratedTopCell{} + where rule2LHS{}(Var'Hash'Configuration:SortGeneratedTopCell{},VarA:SortAnnotationList{},VarT:SortType{},VarX:SortData{},Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'10:SortSenderaddrCell{},Var'Unds'11:SortMychainidCell{},Var'Unds'12:SortNonceCell{},Var'Unds'13:SortBigmapsCell{},Var'Unds'14:SortScriptCell{},Var'Unds'15:SortStackCell{},Var'Unds'16:SortInputstackCell{},Var'Unds'17:SortExpectedCell{},Var'Unds'18:SortPreCell{},Var'Unds'19:SortPostCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'20:SortInvsCell{},Var'Unds'21:SortCutpointsCell{},Var'Unds'22:SortSymbolsCell{},Var'Unds'23:SortReturncodeCell{},Var'Unds'24:SortAssumeFailedCell{},Var'Unds'25:SortTraceCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},Var'Unds'8:SortKnownaddrsCell{},Var'Unds'9:SortSourceaddrCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}) := + \and{SortGeneratedTopCell{}} ( + \equals{SortBool{},SortGeneratedTopCell{}}( + Lbl'Unds'andBool'Unds'{}(LblnotBool'Unds'{}(LblisValue'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'Data{}(VarX:SortData{})),LblnotBool'Unds'{}(LblisSymbolicData{}(kseq{}(inj{SortData{}, SortKItem{}}(VarX:SortData{}),dotk{}())))), + \dv{SortBool{}}("true")), \and{SortGeneratedTopCell{}}(Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},Var'Unds'8:SortKnownaddrsCell{},Var'Unds'9:SortSourceaddrCell{},Var'Unds'10:SortSenderaddrCell{},Var'Unds'11:SortMychainidCell{},Var'Unds'12:SortNonceCell{},Var'Unds'13:SortBigmapsCell{},Var'Unds'14:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(kseq{}(inj{SortInstruction{}, SortKItem{}}(LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(VarA:SortAnnotationList{},VarT:SortType{},VarX:SortData{})),Var'Unds'DotVar2:SortK{})),Var'Unds'15:SortStackCell{},Var'Unds'16:SortInputstackCell{},Var'Unds'17:SortExpectedCell{},Var'Unds'18:SortPreCell{},Var'Unds'19:SortPostCell{},Var'Unds'20:SortInvsCell{},Var'Unds'21:SortCutpointsCell{},Var'Unds'22:SortSymbolsCell{},Var'Unds'23:SortReturncodeCell{},Var'Unds'24:SortAssumeFailedCell{},Var'Unds'25:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{}),Var'Hash'Configuration:SortGeneratedTopCell{})) [] + + axiom{} \rewrites{SortGeneratedTopCell{}} ( + rule2LHS{}(Var'Hash'Configuration:SortGeneratedTopCell{},VarA:SortAnnotationList{},VarT:SortType{},VarX:SortData{},Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'10:SortSenderaddrCell{},Var'Unds'11:SortMychainidCell{},Var'Unds'12:SortNonceCell{},Var'Unds'13:SortBigmapsCell{},Var'Unds'14:SortScriptCell{},Var'Unds'15:SortStackCell{},Var'Unds'16:SortInputstackCell{},Var'Unds'17:SortExpectedCell{},Var'Unds'18:SortPreCell{},Var'Unds'19:SortPostCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'20:SortInvsCell{},Var'Unds'21:SortCutpointsCell{},Var'Unds'22:SortSymbolsCell{},Var'Unds'23:SortReturncodeCell{},Var'Unds'24:SortAssumeFailedCell{},Var'Unds'25:SortTraceCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},Var'Unds'8:SortKnownaddrsCell{},Var'Unds'9:SortSourceaddrCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}), + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},Var'Unds'8:SortKnownaddrsCell{},Var'Unds'9:SortSourceaddrCell{},Var'Unds'10:SortSenderaddrCell{},Var'Unds'11:SortMychainidCell{},Var'Unds'12:SortNonceCell{},Var'Unds'13:SortBigmapsCell{},Var'Unds'14:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(kseq{}(inj{SortInstruction{}, SortKItem{}}(LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(VarA:SortAnnotationList{},VarT:SortType{},Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortData{}, SortDataOrSeq{}}(VarX:SortData{}),VarT:SortType{},Lbl'Stop'Map{}(),Lbl'Stop'Map{}(),Var'Hash'Configuration:SortGeneratedTopCell{}))),Var'Unds'DotVar2:SortK{})),Var'Unds'15:SortStackCell{},Var'Unds'16:SortInputstackCell{},Var'Unds'17:SortExpectedCell{},Var'Unds'18:SortPreCell{},Var'Unds'19:SortPostCell{},Var'Unds'20:SortInvsCell{},Var'Unds'21:SortCutpointsCell{},Var'Unds'22:SortSymbolsCell{},Var'Unds'23:SortReturncodeCell{},Var'Unds'24:SortAssumeFailedCell{},Var'Unds'25:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{}))) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("885"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(885,8,887,39)"), UNIQUE'Unds'ID{}("3b3b1ed65e9f379b9dfcd32d848f052e2e735adeff3bc281648b20c3b0817c33")] + +// rule ``(``(_0,_1,``(T),``(inj{Data,PreData}(D)),_2,_3,_4,_5,_6,_7,_8,_9,_10,``(BigMaps) #as _28,_11,``(`#ConvertStorageToNative_MICHELSON_KItem`(.KList)~>_DotVar2),_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22),_DotVar0) #as #Configuration=>``(``(_0,_1,``(inj{Type,PreType}(`#ConvertToType(_)_MICHELSON_Type_PreType`(T))),``(inj{Data,PreData}(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Data,DataOrSeq}(D),`#ConvertToType(_)_MICHELSON_Type_PreType`(T),`.Map`(.KList),BigMaps,#Configuration))),_2,_3,_4,_5,_6,_7,_8,_9,_10,_28,_11,``(_DotVar2),_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22),_DotVar0) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(1f5958bcbe8ec3cafa12b7b7d395393caa8ccb21ae36a33e6112abf35fa29be8), contentStartColumn(8), contentStartLine(540), org.kframework.attributes.Location(Location(540,8,543,36)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + alias rule3LHS{}(SortGeneratedTopCell{},SortMap{},SortData{},SortPreType{},SortParamtypeCell{},SortParamvalueCell{},SortNonceCell{},SortScriptCell{},SortStackCell{},SortInputstackCell{},SortExpectedCell{},SortPreCell{},SortPostCell{},SortInvsCell{},SortCutpointsCell{},SortSymbolsCell{},SortMybalanceCell{},SortReturncodeCell{},SortAssumeFailedCell{},SortTraceCell{},SortBigmapsCell{},SortMyamountCell{},SortMynowCell{},SortMyaddrCell{},SortKnownaddrsCell{},SortSourceaddrCell{},SortSenderaddrCell{},SortMychainidCell{},SortGeneratedCounterCell{},SortK{}) : SortGeneratedTopCell{} + where rule3LHS{}(Var'Hash'Configuration:SortGeneratedTopCell{},VarBigMaps:SortMap{},VarD:SortData{},VarT:SortPreType{},Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'10:SortNonceCell{},Var'Unds'11:SortScriptCell{},Var'Unds'12:SortStackCell{},Var'Unds'13:SortInputstackCell{},Var'Unds'14:SortExpectedCell{},Var'Unds'15:SortPreCell{},Var'Unds'16:SortPostCell{},Var'Unds'17:SortInvsCell{},Var'Unds'18:SortCutpointsCell{},Var'Unds'19:SortSymbolsCell{},Var'Unds'2:SortMybalanceCell{},Var'Unds'20:SortReturncodeCell{},Var'Unds'21:SortAssumeFailedCell{},Var'Unds'22:SortTraceCell{},Var'Unds'28:SortBigmapsCell{},Var'Unds'3:SortMyamountCell{},Var'Unds'4:SortMynowCell{},Var'Unds'5:SortMyaddrCell{},Var'Unds'6:SortKnownaddrsCell{},Var'Unds'7:SortSourceaddrCell{},Var'Unds'8:SortSenderaddrCell{},Var'Unds'9:SortMychainidCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}) := + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), \and{SortGeneratedTopCell{}}(Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Lbl'-LT-'storagetype'-GT-'{}(VarT:SortPreType{}),Lbl'-LT-'storagevalue'-GT-'{}(inj{SortData{}, SortPreData{}}(VarD:SortData{})),Var'Unds'2:SortMybalanceCell{},Var'Unds'3:SortMyamountCell{},Var'Unds'4:SortMynowCell{},Var'Unds'5:SortMyaddrCell{},Var'Unds'6:SortKnownaddrsCell{},Var'Unds'7:SortSourceaddrCell{},Var'Unds'8:SortSenderaddrCell{},Var'Unds'9:SortMychainidCell{},Var'Unds'10:SortNonceCell{},\and{SortBigmapsCell{}}(Lbl'-LT-'bigmaps'-GT-'{}(VarBigMaps:SortMap{}),Var'Unds'28:SortBigmapsCell{}),Var'Unds'11:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(kseq{}(Lbl'Hash'ConvertStorageToNative'Unds'MICHELSON'Unds'KItem{}(),Var'Unds'DotVar2:SortK{})),Var'Unds'12:SortStackCell{},Var'Unds'13:SortInputstackCell{},Var'Unds'14:SortExpectedCell{},Var'Unds'15:SortPreCell{},Var'Unds'16:SortPostCell{},Var'Unds'17:SortInvsCell{},Var'Unds'18:SortCutpointsCell{},Var'Unds'19:SortSymbolsCell{},Var'Unds'20:SortReturncodeCell{},Var'Unds'21:SortAssumeFailedCell{},Var'Unds'22:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{}),Var'Hash'Configuration:SortGeneratedTopCell{})) [] + + axiom{} \rewrites{SortGeneratedTopCell{}} ( + rule3LHS{}(Var'Hash'Configuration:SortGeneratedTopCell{},VarBigMaps:SortMap{},VarD:SortData{},VarT:SortPreType{},Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'10:SortNonceCell{},Var'Unds'11:SortScriptCell{},Var'Unds'12:SortStackCell{},Var'Unds'13:SortInputstackCell{},Var'Unds'14:SortExpectedCell{},Var'Unds'15:SortPreCell{},Var'Unds'16:SortPostCell{},Var'Unds'17:SortInvsCell{},Var'Unds'18:SortCutpointsCell{},Var'Unds'19:SortSymbolsCell{},Var'Unds'2:SortMybalanceCell{},Var'Unds'20:SortReturncodeCell{},Var'Unds'21:SortAssumeFailedCell{},Var'Unds'22:SortTraceCell{},Var'Unds'28:SortBigmapsCell{},Var'Unds'3:SortMyamountCell{},Var'Unds'4:SortMynowCell{},Var'Unds'5:SortMyaddrCell{},Var'Unds'6:SortKnownaddrsCell{},Var'Unds'7:SortSourceaddrCell{},Var'Unds'8:SortSenderaddrCell{},Var'Unds'9:SortMychainidCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}), + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Lbl'-LT-'storagetype'-GT-'{}(inj{SortType{}, SortPreType{}}(Lbl'Hash'ConvertToType'LParUndsRParUnds'MICHELSON'Unds'Type'Unds'PreType{}(VarT:SortPreType{}))),Lbl'-LT-'storagevalue'-GT-'{}(inj{SortData{}, SortPreData{}}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortData{}, SortDataOrSeq{}}(VarD:SortData{}),Lbl'Hash'ConvertToType'LParUndsRParUnds'MICHELSON'Unds'Type'Unds'PreType{}(VarT:SortPreType{}),Lbl'Stop'Map{}(),VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}))),Var'Unds'2:SortMybalanceCell{},Var'Unds'3:SortMyamountCell{},Var'Unds'4:SortMynowCell{},Var'Unds'5:SortMyaddrCell{},Var'Unds'6:SortKnownaddrsCell{},Var'Unds'7:SortSourceaddrCell{},Var'Unds'8:SortSenderaddrCell{},Var'Unds'9:SortMychainidCell{},Var'Unds'10:SortNonceCell{},Var'Unds'28:SortBigmapsCell{},Var'Unds'11:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(Var'Unds'DotVar2:SortK{}),Var'Unds'12:SortStackCell{},Var'Unds'13:SortInputstackCell{},Var'Unds'14:SortExpectedCell{},Var'Unds'15:SortPreCell{},Var'Unds'16:SortPostCell{},Var'Unds'17:SortInvsCell{},Var'Unds'18:SortCutpointsCell{},Var'Unds'19:SortSymbolsCell{},Var'Unds'20:SortReturncodeCell{},Var'Unds'21:SortAssumeFailedCell{},Var'Unds'22:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{}))) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("540"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(540,8,543,36)"), UNIQUE'Unds'ID{}("1f5958bcbe8ec3cafa12b7b7d395393caa8ccb21ae36a33e6112abf35fa29be8")] + +// rule ``(``(_1,_2,_3,_4,_5,_6,_7,_8,``(Addrs) #as _25,_9,_10,_11,_12,``(BigMaps) #as _26,_13,``(`#LoadInputStack_MICHELSON_KItem`(.KList)~>_DotVar2),``(_0),``(inj{OutputStack,KItem}(Actual)) #as _31,_14,_15,_16,_17,_18,_19,_20,_21,_22),_DotVar0) #as #Configuration=>``(``(_1,_2,_3,_4,_5,_6,_7,_8,_25,_9,_10,_11,_12,_26,_13,``(_DotVar2),``(`#StackToNative(_,_,_)_MICHELSON_InternalStack_OutputStack_Map_Map`(Actual,Addrs,BigMaps,#Configuration)),_31,_14,_15,_16,_17,_18,_19,_20,_21,_22),_DotVar0) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(77c23097aedf94f0d8df42a2d6b693723222b76b6c93e12689d6c1991254a875), contentStartColumn(8), contentStartLine(575), org.kframework.attributes.Location(Location(575,8,579,36)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + alias rule4LHS{}(SortGeneratedTopCell{},SortOutputStack{},SortMap{},SortMap{},SortInternalStack{},SortParamtypeCell{},SortSenderaddrCell{},SortMychainidCell{},SortNonceCell{},SortScriptCell{},SortExpectedCell{},SortPreCell{},SortPostCell{},SortInvsCell{},SortCutpointsCell{},SortSymbolsCell{},SortParamvalueCell{},SortReturncodeCell{},SortAssumeFailedCell{},SortTraceCell{},SortKnownaddrsCell{},SortBigmapsCell{},SortStoragetypeCell{},SortInputstackCell{},SortStoragevalueCell{},SortMybalanceCell{},SortMyamountCell{},SortMynowCell{},SortMyaddrCell{},SortSourceaddrCell{},SortGeneratedCounterCell{},SortK{}) : SortGeneratedTopCell{} + where rule4LHS{}(Var'Hash'Configuration:SortGeneratedTopCell{},VarActual:SortOutputStack{},VarAddrs:SortMap{},VarBigMaps:SortMap{},Var'Unds'0:SortInternalStack{},Var'Unds'1:SortParamtypeCell{},Var'Unds'10:SortSenderaddrCell{},Var'Unds'11:SortMychainidCell{},Var'Unds'12:SortNonceCell{},Var'Unds'13:SortScriptCell{},Var'Unds'14:SortExpectedCell{},Var'Unds'15:SortPreCell{},Var'Unds'16:SortPostCell{},Var'Unds'17:SortInvsCell{},Var'Unds'18:SortCutpointsCell{},Var'Unds'19:SortSymbolsCell{},Var'Unds'2:SortParamvalueCell{},Var'Unds'20:SortReturncodeCell{},Var'Unds'21:SortAssumeFailedCell{},Var'Unds'22:SortTraceCell{},Var'Unds'25:SortKnownaddrsCell{},Var'Unds'26:SortBigmapsCell{},Var'Unds'3:SortStoragetypeCell{},Var'Unds'31:SortInputstackCell{},Var'Unds'4:SortStoragevalueCell{},Var'Unds'5:SortMybalanceCell{},Var'Unds'6:SortMyamountCell{},Var'Unds'7:SortMynowCell{},Var'Unds'8:SortMyaddrCell{},Var'Unds'9:SortSourceaddrCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}) := + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), \and{SortGeneratedTopCell{}}(Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'1:SortParamtypeCell{},Var'Unds'2:SortParamvalueCell{},Var'Unds'3:SortStoragetypeCell{},Var'Unds'4:SortStoragevalueCell{},Var'Unds'5:SortMybalanceCell{},Var'Unds'6:SortMyamountCell{},Var'Unds'7:SortMynowCell{},Var'Unds'8:SortMyaddrCell{},\and{SortKnownaddrsCell{}}(Lbl'-LT-'knownaddrs'-GT-'{}(VarAddrs:SortMap{}),Var'Unds'25:SortKnownaddrsCell{}),Var'Unds'9:SortSourceaddrCell{},Var'Unds'10:SortSenderaddrCell{},Var'Unds'11:SortMychainidCell{},Var'Unds'12:SortNonceCell{},\and{SortBigmapsCell{}}(Lbl'-LT-'bigmaps'-GT-'{}(VarBigMaps:SortMap{}),Var'Unds'26:SortBigmapsCell{}),Var'Unds'13:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(kseq{}(Lbl'Hash'LoadInputStack'Unds'MICHELSON'Unds'KItem{}(),Var'Unds'DotVar2:SortK{})),Lbl'-LT-'stack'-GT-'{}(Var'Unds'0:SortInternalStack{}),\and{SortInputstackCell{}}(Lbl'-LT-'inputstack'-GT-'{}(kseq{}(inj{SortOutputStack{}, SortKItem{}}(VarActual:SortOutputStack{}),dotk{}())),Var'Unds'31:SortInputstackCell{}),Var'Unds'14:SortExpectedCell{},Var'Unds'15:SortPreCell{},Var'Unds'16:SortPostCell{},Var'Unds'17:SortInvsCell{},Var'Unds'18:SortCutpointsCell{},Var'Unds'19:SortSymbolsCell{},Var'Unds'20:SortReturncodeCell{},Var'Unds'21:SortAssumeFailedCell{},Var'Unds'22:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{}),Var'Hash'Configuration:SortGeneratedTopCell{})) [] + + axiom{} \rewrites{SortGeneratedTopCell{}} ( + rule4LHS{}(Var'Hash'Configuration:SortGeneratedTopCell{},VarActual:SortOutputStack{},VarAddrs:SortMap{},VarBigMaps:SortMap{},Var'Unds'0:SortInternalStack{},Var'Unds'1:SortParamtypeCell{},Var'Unds'10:SortSenderaddrCell{},Var'Unds'11:SortMychainidCell{},Var'Unds'12:SortNonceCell{},Var'Unds'13:SortScriptCell{},Var'Unds'14:SortExpectedCell{},Var'Unds'15:SortPreCell{},Var'Unds'16:SortPostCell{},Var'Unds'17:SortInvsCell{},Var'Unds'18:SortCutpointsCell{},Var'Unds'19:SortSymbolsCell{},Var'Unds'2:SortParamvalueCell{},Var'Unds'20:SortReturncodeCell{},Var'Unds'21:SortAssumeFailedCell{},Var'Unds'22:SortTraceCell{},Var'Unds'25:SortKnownaddrsCell{},Var'Unds'26:SortBigmapsCell{},Var'Unds'3:SortStoragetypeCell{},Var'Unds'31:SortInputstackCell{},Var'Unds'4:SortStoragevalueCell{},Var'Unds'5:SortMybalanceCell{},Var'Unds'6:SortMyamountCell{},Var'Unds'7:SortMynowCell{},Var'Unds'8:SortMyaddrCell{},Var'Unds'9:SortSourceaddrCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}), + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'1:SortParamtypeCell{},Var'Unds'2:SortParamvalueCell{},Var'Unds'3:SortStoragetypeCell{},Var'Unds'4:SortStoragevalueCell{},Var'Unds'5:SortMybalanceCell{},Var'Unds'6:SortMyamountCell{},Var'Unds'7:SortMynowCell{},Var'Unds'8:SortMyaddrCell{},Var'Unds'25:SortKnownaddrsCell{},Var'Unds'9:SortSourceaddrCell{},Var'Unds'10:SortSenderaddrCell{},Var'Unds'11:SortMychainidCell{},Var'Unds'12:SortNonceCell{},Var'Unds'26:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(Var'Unds'DotVar2:SortK{}),Lbl'-LT-'stack'-GT-'{}(Lbl'Hash'StackToNative'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'InternalStack'Unds'OutputStack'Unds'Map'Unds'Map{}(VarActual:SortOutputStack{},VarAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{})),Var'Unds'31:SortInputstackCell{},Var'Unds'14:SortExpectedCell{},Var'Unds'15:SortPreCell{},Var'Unds'16:SortPostCell{},Var'Unds'17:SortInvsCell{},Var'Unds'18:SortCutpointsCell{},Var'Unds'19:SortSymbolsCell{},Var'Unds'20:SortReturncodeCell{},Var'Unds'21:SortAssumeFailedCell{},Var'Unds'22:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{}))) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("575"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(575,8,579,36)"), UNIQUE'Unds'ID{}("77c23097aedf94f0d8df42a2d6b693723222b76b6c93e12689d6c1991254a875")] + +// rule ``(``(``(T),``(inj{Data,PreData}(D)),_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,``(BigMaps) #as _28,_11,``(`#ConvertParamToNative_MICHELSON_KItem`(.KList)~>_DotVar2),_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22),_DotVar0) #as #Configuration=>``(``(``(inj{Type,PreType}(`#ConvertToType(_)_MICHELSON_Type_PreType`(T))),``(inj{Data,PreData}(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Data,DataOrSeq}(D),`#ConvertToType(_)_MICHELSON_Type_PreType`(T),`.Map`(.KList),BigMaps,#Configuration))),_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_28,_11,``(_DotVar2),_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22),_DotVar0) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(52d3710f51100316601ac1c6380c95efcb0c1aefa833120b515d334f58b09448), contentStartColumn(8), contentStartLine(530), org.kframework.attributes.Location(Location(530,8,533,36)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + alias rule5LHS{}(SortGeneratedTopCell{},SortMap{},SortData{},SortPreType{},SortStoragetypeCell{},SortStoragevalueCell{},SortNonceCell{},SortScriptCell{},SortStackCell{},SortInputstackCell{},SortExpectedCell{},SortPreCell{},SortPostCell{},SortInvsCell{},SortCutpointsCell{},SortSymbolsCell{},SortMybalanceCell{},SortReturncodeCell{},SortAssumeFailedCell{},SortTraceCell{},SortBigmapsCell{},SortMyamountCell{},SortMynowCell{},SortMyaddrCell{},SortKnownaddrsCell{},SortSourceaddrCell{},SortSenderaddrCell{},SortMychainidCell{},SortGeneratedCounterCell{},SortK{}) : SortGeneratedTopCell{} + where rule5LHS{}(Var'Hash'Configuration:SortGeneratedTopCell{},VarBigMaps:SortMap{},VarD:SortData{},VarT:SortPreType{},Var'Unds'0:SortStoragetypeCell{},Var'Unds'1:SortStoragevalueCell{},Var'Unds'10:SortNonceCell{},Var'Unds'11:SortScriptCell{},Var'Unds'12:SortStackCell{},Var'Unds'13:SortInputstackCell{},Var'Unds'14:SortExpectedCell{},Var'Unds'15:SortPreCell{},Var'Unds'16:SortPostCell{},Var'Unds'17:SortInvsCell{},Var'Unds'18:SortCutpointsCell{},Var'Unds'19:SortSymbolsCell{},Var'Unds'2:SortMybalanceCell{},Var'Unds'20:SortReturncodeCell{},Var'Unds'21:SortAssumeFailedCell{},Var'Unds'22:SortTraceCell{},Var'Unds'28:SortBigmapsCell{},Var'Unds'3:SortMyamountCell{},Var'Unds'4:SortMynowCell{},Var'Unds'5:SortMyaddrCell{},Var'Unds'6:SortKnownaddrsCell{},Var'Unds'7:SortSourceaddrCell{},Var'Unds'8:SortSenderaddrCell{},Var'Unds'9:SortMychainidCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}) := + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), \and{SortGeneratedTopCell{}}(Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Lbl'-LT-'paramtype'-GT-'{}(VarT:SortPreType{}),Lbl'-LT-'paramvalue'-GT-'{}(inj{SortData{}, SortPreData{}}(VarD:SortData{})),Var'Unds'0:SortStoragetypeCell{},Var'Unds'1:SortStoragevalueCell{},Var'Unds'2:SortMybalanceCell{},Var'Unds'3:SortMyamountCell{},Var'Unds'4:SortMynowCell{},Var'Unds'5:SortMyaddrCell{},Var'Unds'6:SortKnownaddrsCell{},Var'Unds'7:SortSourceaddrCell{},Var'Unds'8:SortSenderaddrCell{},Var'Unds'9:SortMychainidCell{},Var'Unds'10:SortNonceCell{},\and{SortBigmapsCell{}}(Lbl'-LT-'bigmaps'-GT-'{}(VarBigMaps:SortMap{}),Var'Unds'28:SortBigmapsCell{}),Var'Unds'11:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(kseq{}(Lbl'Hash'ConvertParamToNative'Unds'MICHELSON'Unds'KItem{}(),Var'Unds'DotVar2:SortK{})),Var'Unds'12:SortStackCell{},Var'Unds'13:SortInputstackCell{},Var'Unds'14:SortExpectedCell{},Var'Unds'15:SortPreCell{},Var'Unds'16:SortPostCell{},Var'Unds'17:SortInvsCell{},Var'Unds'18:SortCutpointsCell{},Var'Unds'19:SortSymbolsCell{},Var'Unds'20:SortReturncodeCell{},Var'Unds'21:SortAssumeFailedCell{},Var'Unds'22:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{}),Var'Hash'Configuration:SortGeneratedTopCell{})) [] + + axiom{} \rewrites{SortGeneratedTopCell{}} ( + rule5LHS{}(Var'Hash'Configuration:SortGeneratedTopCell{},VarBigMaps:SortMap{},VarD:SortData{},VarT:SortPreType{},Var'Unds'0:SortStoragetypeCell{},Var'Unds'1:SortStoragevalueCell{},Var'Unds'10:SortNonceCell{},Var'Unds'11:SortScriptCell{},Var'Unds'12:SortStackCell{},Var'Unds'13:SortInputstackCell{},Var'Unds'14:SortExpectedCell{},Var'Unds'15:SortPreCell{},Var'Unds'16:SortPostCell{},Var'Unds'17:SortInvsCell{},Var'Unds'18:SortCutpointsCell{},Var'Unds'19:SortSymbolsCell{},Var'Unds'2:SortMybalanceCell{},Var'Unds'20:SortReturncodeCell{},Var'Unds'21:SortAssumeFailedCell{},Var'Unds'22:SortTraceCell{},Var'Unds'28:SortBigmapsCell{},Var'Unds'3:SortMyamountCell{},Var'Unds'4:SortMynowCell{},Var'Unds'5:SortMyaddrCell{},Var'Unds'6:SortKnownaddrsCell{},Var'Unds'7:SortSourceaddrCell{},Var'Unds'8:SortSenderaddrCell{},Var'Unds'9:SortMychainidCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}), + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Lbl'-LT-'paramtype'-GT-'{}(inj{SortType{}, SortPreType{}}(Lbl'Hash'ConvertToType'LParUndsRParUnds'MICHELSON'Unds'Type'Unds'PreType{}(VarT:SortPreType{}))),Lbl'-LT-'paramvalue'-GT-'{}(inj{SortData{}, SortPreData{}}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortData{}, SortDataOrSeq{}}(VarD:SortData{}),Lbl'Hash'ConvertToType'LParUndsRParUnds'MICHELSON'Unds'Type'Unds'PreType{}(VarT:SortPreType{}),Lbl'Stop'Map{}(),VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}))),Var'Unds'0:SortStoragetypeCell{},Var'Unds'1:SortStoragevalueCell{},Var'Unds'2:SortMybalanceCell{},Var'Unds'3:SortMyamountCell{},Var'Unds'4:SortMynowCell{},Var'Unds'5:SortMyaddrCell{},Var'Unds'6:SortKnownaddrsCell{},Var'Unds'7:SortSourceaddrCell{},Var'Unds'8:SortSenderaddrCell{},Var'Unds'9:SortMychainidCell{},Var'Unds'10:SortNonceCell{},Var'Unds'28:SortBigmapsCell{},Var'Unds'11:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(Var'Unds'DotVar2:SortK{}),Var'Unds'12:SortStackCell{},Var'Unds'13:SortInputstackCell{},Var'Unds'14:SortExpectedCell{},Var'Unds'15:SortPreCell{},Var'Unds'16:SortPostCell{},Var'Unds'17:SortInvsCell{},Var'Unds'18:SortCutpointsCell{},Var'Unds'19:SortSymbolsCell{},Var'Unds'20:SortReturncodeCell{},Var'Unds'21:SortAssumeFailedCell{},Var'Unds'22:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{}))) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("530"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(530,8,533,36)"), UNIQUE'Unds'ID{}("52d3710f51100316601ac1c6380c95efcb0c1aefa833120b515d334f58b09448")] + +// rule `#AllTypesKnown(_)_MICHELSON_Bool_Set`(_0)=>#token("true","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(8ecc759b73f3da2c10220f24d386a571f22beceeed01b72de6a3e33007680da6), contentStartColumn(8), contentStartLine(2207), org.kframework.attributes.Location(Location(2201,8,2201,33)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]), owise] + axiom{R} \implies{R} ( + \and{R} ( + \not{R} ( + \or{R} ( + \exists{R} (Var'Unds'2:SortSymbolicData{}, + \exists{R} (Var'Unds'3:SortSet{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortSet{}, R} ( + \and{SortSet{}} ( + Var'Unds'0:SortSet{}, + Lbl'Unds'Set'Unds'{}(LblSetItem{}(inj{SortSymbolicElement{}, SortKItem{}}(Lbl'Hash'SymbolicElement'LParUndsCommUndsRParUnds'MICHELSON'Unds'SymbolicElement'Unds'SymbolicData'Unds'Type{}(Var'Unds'2:SortSymbolicData{},Lbl'Hash'UnknownType'Unds'MICHELSON'Unds'Type{}()))),Var'Unds'3:SortSet{}) + )), + \top{R} () + ) + ))), + \bottom{R}() + ) + ), + \top{R}() + ), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'AllTypesKnown'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'Set{}(Var'Unds'0:SortSet{}), + \dv{SortBool{}}("true")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2207"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2201,8,2201,33)"), owise{}(), UNIQUE'Unds'ID{}("8ecc759b73f3da2c10220f24d386a571f22beceeed01b72de6a3e33007680da6")] + +// rule `#AllTypesKnown(_)_MICHELSON_Bool_Set`(`_Set_`(`SetItem`(inj{SymbolicElement,KItem}(`#SymbolicElement(_,_)_MICHELSON_SymbolicElement_SymbolicData_Type`(_0,`#UnknownType_MICHELSON_Type`(.KList)))),_1))=>#token("false","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(41dfc226626547057f65d3aeaa1e724256952178a641d83eb29343b4c07fb8f4), contentStartColumn(8), contentStartLine(2206), org.kframework.attributes.Location(Location(2200,8,2200,77)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'AllTypesKnown'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'Set{}(Lbl'Unds'Set'Unds'{}(LblSetItem{}(inj{SortSymbolicElement{}, SortKItem{}}(Lbl'Hash'SymbolicElement'LParUndsCommUndsRParUnds'MICHELSON'Unds'SymbolicElement'Unds'SymbolicData'Unds'Type{}(Var'Unds'0:SortSymbolicData{},Lbl'Hash'UnknownType'Unds'MICHELSON'Unds'Type{}()))),Var'Unds'1:SortSet{})), + \dv{SortBool{}}("false")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2206"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2200,8,2200,77)"), UNIQUE'Unds'ID{}("41dfc226626547057f65d3aeaa1e724256952178a641d83eb29343b4c07fb8f4")] + +// rule `#BigMapsEntryListToKMap(_)_MICHELSON_Map_BigMapEntryList`(`.List{"_;__MICHELSON-COMMON-SYNTAX_BigMapEntryList_BigMapEntry_BigMapEntryList"}_BigMapEntryList`(.KList))=>`.Map`(.KList) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(0616328c289f062342d243dc088dc7b710659a72a753a622aeefc9e105138d1e), contentStartColumn(8), contentStartLine(462), org.kframework.attributes.Location(Location(462,8,462,57)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortMap{},R} ( + Lbl'Hash'BigMapsEntryListToKMap'LParUndsRParUnds'MICHELSON'Unds'Map'Unds'BigMapEntryList{}(Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntryList'Unds'BigMapEntry'Unds'BigMapEntryList'QuotRBraUnds'BigMapEntryList{}()), + Lbl'Stop'Map{}()), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("462"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(462,8,462,57)"), UNIQUE'Unds'ID{}("0616328c289f062342d243dc088dc7b710659a72a753a622aeefc9e105138d1e")] + +// rule `#BigMapsEntryListToKMap(_)_MICHELSON_Map_BigMapEntryList`(`_;__MICHELSON-COMMON-SYNTAX_BigMapEntryList_BigMapEntry_BigMapEntryList`(E,Es))=>`_Map_`(`#BigMapsEntryToKMap(_)_MICHELSON_Map_BigMapEntry`(E),`#BigMapsEntryListToKMap(_)_MICHELSON_Map_BigMapEntryList`(Es)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(a2f0be447d1ad530ffe387e6d31a81184961454ca37d44988ea0c3fb080f4f47), contentStartColumn(8), contentStartLine(463), org.kframework.attributes.Location(Location(463,8,463,93)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortMap{},R} ( + Lbl'Hash'BigMapsEntryListToKMap'LParUndsRParUnds'MICHELSON'Unds'Map'Unds'BigMapEntryList{}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntryList'Unds'BigMapEntry'Unds'BigMapEntryList{}(VarE:SortBigMapEntry{},VarEs:SortBigMapEntryList{})), + Lbl'Unds'Map'Unds'{}(Lbl'Hash'BigMapsEntryToKMap'LParUndsRParUnds'MICHELSON'Unds'Map'Unds'BigMapEntry{}(VarE:SortBigMapEntry{}),Lbl'Hash'BigMapsEntryListToKMap'LParUndsRParUnds'MICHELSON'Unds'Map'Unds'BigMapEntryList{}(VarEs:SortBigMapEntryList{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("463"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(463,8,463,93)"), UNIQUE'Unds'ID{}("a2f0be447d1ad530ffe387e6d31a81184961454ca37d44988ea0c3fb080f4f47")] + +// rule `#BigMapsEntryToKMap(_)_MICHELSON_Map_BigMapEntry`(`Big_map_____MICHELSON-COMMON-SYNTAX_BigMapEntry_Int_Type_Type_EmptyBlock`(I,T1,T2,`{}_MICHELSON-COMMON-SYNTAX_EmptyBlock`(.KList) #as _1))=>`_|->_`(inj{Int,KItem}(I),`#BigMap(_,_)_MICHELSON_KItem_SequenceData_Type`(inj{EmptyBlock,SequenceData}(_1),`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(inj{MapTypeName,BinaryTypeName}(`big_map_MICHELSON-COMMON-SYNTAX_MapTypeName`(.KList)),`.List{"___MICHELSON-COMMON-SYNTAX_AnnotationList_Annotation_AnnotationList"}_AnnotationList`(.KList),T1,T2))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(e40dcbc5e05fd6e29c453781716a496eb66d724e0c8bf37742e32e0757c5ed4b), contentStartColumn(8), contentStartLine(466), org.kframework.attributes.Location(Location(466,8,466,111)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortMap{},R} ( + Lbl'Hash'BigMapsEntryToKMap'LParUndsRParUnds'MICHELSON'Unds'Map'Unds'BigMapEntry{}(LblBig'Unds'map'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntry'Unds'Int'Unds'Type'Unds'Type'Unds'EmptyBlock{}(VarI:SortInt{},VarT1:SortType{},VarT2:SortType{},\and{SortEmptyBlock{}}(Lbl'LBraRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'EmptyBlock{}(),Var'Unds'1:SortEmptyBlock{}))), + Lbl'UndsPipe'-'-GT-Unds'{}(inj{SortInt{}, SortKItem{}}(VarI:SortInt{}),Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(inj{SortEmptyBlock{}, SortSequenceData{}}(Var'Unds'1:SortEmptyBlock{}),Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(inj{SortMapTypeName{}, SortBinaryTypeName{}}(Lblbig'Unds'map'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}()),Lbl'Stop'List'LBraQuotUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList'QuotRBraUnds'AnnotationList{}(),VarT1:SortType{},VarT2:SortType{})))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("466"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(466,8,466,111)"), UNIQUE'Unds'ID{}("e40dcbc5e05fd6e29c453781716a496eb66d724e0c8bf37742e32e0757c5ed4b")] + +// rule `#BigMapsEntryToKMap(_)_MICHELSON_Map_BigMapEntry`(`Big_map_____MICHELSON-COMMON-SYNTAX_BigMapEntry_Int_Type_Type_MapLiteral`(I,T1,T2,ML))=>`_|->_`(inj{Int,KItem}(I),`#BigMap(_,_)_MICHELSON_KItem_SequenceData_Type`(inj{MapLiteral,SequenceData}(ML),`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(inj{MapTypeName,BinaryTypeName}(`big_map_MICHELSON-COMMON-SYNTAX_MapTypeName`(.KList)),`.List{"___MICHELSON-COMMON-SYNTAX_AnnotationList_Annotation_AnnotationList"}_AnnotationList`(.KList),T1,T2))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(0ae452d25f685ddc2c823c074ca8fa85e1ae1f578c7580ae440256aa146c6907), contentStartColumn(8), contentStartLine(467), org.kframework.attributes.Location(Location(467,8,467,111)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortMap{},R} ( + Lbl'Hash'BigMapsEntryToKMap'LParUndsRParUnds'MICHELSON'Unds'Map'Unds'BigMapEntry{}(LblBig'Unds'map'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'BigMapEntry'Unds'Int'Unds'Type'Unds'Type'Unds'MapLiteral{}(VarI:SortInt{},VarT1:SortType{},VarT2:SortType{},VarML:SortMapLiteral{})), + Lbl'UndsPipe'-'-GT-Unds'{}(inj{SortInt{}, SortKItem{}}(VarI:SortInt{}),Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(inj{SortMapLiteral{}, SortSequenceData{}}(VarML:SortMapLiteral{}),Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(inj{SortMapTypeName{}, SortBinaryTypeName{}}(Lblbig'Unds'map'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}()),Lbl'Stop'List'LBraQuotUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList'QuotRBraUnds'AnnotationList{}(),VarT1:SortType{},VarT2:SortType{})))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("467"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(467,8,467,111)"), UNIQUE'Unds'ID{}("0ae452d25f685ddc2c823c074ca8fa85e1ae1f578c7580ae440256aa146c6907")] + +// rule `#Blake2BKeyHash(_)_MICHELSON_String_String`(S)=>S requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(2f2e8d8e80ef5272b3db5e4b841c396bc687a0e29de5fc9bb1d33fd6053fe11a), contentStartColumn(8), contentStartLine(1782), org.kframework.attributes.Location(Location(1776,8,1776,31)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortString{},R} ( + Lbl'Hash'Blake2BKeyHash'LParUndsRParUnds'MICHELSON'Unds'String'Unds'String{}(VarS:SortString{}), + VarS:SortString{}), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1782"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1776,8,1776,31)"), UNIQUE'Unds'ID{}("2f2e8d8e80ef5272b3db5e4b841c396bc687a0e29de5fc9bb1d33fd6053fe11a")] + +// rule #Ceil{Int,#SortParam}(`_%Int_`(@I1,@I2))=>#And{#SortParam}(#And{#SortParam}(#Equals{Bool,#SortParam}(`_=/=Int_`(@I2,#token("0","Int")),#token("true","Bool")),#Ceil{Int,#SortParam}(@I1)),#Ceil{Int,#SortParam}(@I2)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(277564ad2537209fd698729ceaa01973f97125176cf1078f98e2edb7cc190f34), anywhere, contentStartColumn(8), contentStartLine(1015), org.kframework.attributes.Location(Location(1015,8,1015,102)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]), simplification, sortParams([Q0])] + axiom{R,Q0} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{Q0,R} ( + \ceil{SortInt{}, Q0}(Lbl'UndsPerc'Int'Unds'{}(@VarI1:SortInt{},@VarI2:SortInt{})), + \and{Q0}(\and{Q0}(\equals{SortBool{}, Q0}(Lbl'UndsEqlsSlshEqls'Int'Unds'{}(@VarI2:SortInt{},\dv{SortInt{}}("0")),\dv{SortBool{}}("true")),\ceil{SortInt{}, Q0}(@VarI1:SortInt{})),\ceil{SortInt{}, Q0}(@VarI2:SortInt{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), anywhere{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), sortParams{}("[Q0]"), contentStartLine{}("1015"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1015,8,1015,102)"), simplification{}(), UNIQUE'Unds'ID{}("277564ad2537209fd698729ceaa01973f97125176cf1078f98e2edb7cc190f34")] + +// rule #Ceil{Int,#SortParam}(`_/Int_`(@I1,@I2))=>#And{#SortParam}(#And{#SortParam}(#Equals{Bool,#SortParam}(`_=/=Int_`(@I2,#token("0","Int")),#token("true","Bool")),#Ceil{Int,#SortParam}(@I1)),#Ceil{Int,#SortParam}(@I2)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(1eefe48360417c30b8e5f115a539adbc38e337fa903d6c589811e7b619f8d1cd), anywhere, contentStartColumn(8), contentStartLine(1014), org.kframework.attributes.Location(Location(1014,8,1014,102)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]), simplification, sortParams([Q0])] + axiom{R,Q0} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{Q0,R} ( + \ceil{SortInt{}, Q0}(Lbl'UndsSlsh'Int'Unds'{}(@VarI1:SortInt{},@VarI2:SortInt{})), + \and{Q0}(\and{Q0}(\equals{SortBool{}, Q0}(Lbl'UndsEqlsSlshEqls'Int'Unds'{}(@VarI2:SortInt{},\dv{SortInt{}}("0")),\dv{SortBool{}}("true")),\ceil{SortInt{}, Q0}(@VarI1:SortInt{})),\ceil{SortInt{}, Q0}(@VarI2:SortInt{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), anywhere{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), sortParams{}("[Q0]"), contentStartLine{}("1014"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1014,8,1014,102)"), simplification{}(), UNIQUE'Unds'ID{}("1eefe48360417c30b8e5f115a539adbc38e337fa903d6c589811e7b619f8d1cd")] + +// rule #Ceil{Int,#SortParam}(`_<#And{#SortParam}(#And{#SortParam}(#Equals{Bool,#SortParam}(`_>=Int_`(@I2,#token("0","Int")),#token("true","Bool")),#Ceil{Int,#SortParam}(@I1)),#Ceil{Int,#SortParam}(@I2)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(0b052005b3756fb7082a3e365e1de3b170b4b0d828aab504a9ec2cfd19666528), anywhere, contentStartColumn(8), contentStartLine(1018), org.kframework.attributes.Location(Location(1018,8,1018,102)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]), simplification, sortParams([Q0])] + axiom{R,Q0} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{Q0,R} ( + \ceil{SortInt{}, Q0}(Lbl'Unds-LT--LT-'Int'Unds'{}(@VarI1:SortInt{},@VarI2:SortInt{})), + \and{Q0}(\and{Q0}(\equals{SortBool{}, Q0}(Lbl'Unds-GT-Eqls'Int'Unds'{}(@VarI2:SortInt{},\dv{SortInt{}}("0")),\dv{SortBool{}}("true")),\ceil{SortInt{}, Q0}(@VarI1:SortInt{})),\ceil{SortInt{}, Q0}(@VarI2:SortInt{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), anywhere{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), sortParams{}("[Q0]"), contentStartLine{}("1018"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1018,8,1018,102)"), simplification{}(), UNIQUE'Unds'ID{}("0b052005b3756fb7082a3e365e1de3b170b4b0d828aab504a9ec2cfd19666528")] + +// rule #Ceil{Int,#SortParam}(`_>>Int_`(@I1,@I2))=>#And{#SortParam}(#And{#SortParam}(#Equals{Bool,#SortParam}(`_>=Int_`(@I2,#token("0","Int")),#token("true","Bool")),#Ceil{Int,#SortParam}(@I1)),#Ceil{Int,#SortParam}(@I2)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(8504798d0c71a9c32788426e50147e59ac302592e16aa6bae4511370fd436af8), anywhere, contentStartColumn(8), contentStartLine(1017), org.kframework.attributes.Location(Location(1017,8,1017,102)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]), simplification, sortParams([Q0])] + axiom{R,Q0} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{Q0,R} ( + \ceil{SortInt{}, Q0}(Lbl'Unds-GT--GT-'Int'Unds'{}(@VarI1:SortInt{},@VarI2:SortInt{})), + \and{Q0}(\and{Q0}(\equals{SortBool{}, Q0}(Lbl'Unds-GT-Eqls'Int'Unds'{}(@VarI2:SortInt{},\dv{SortInt{}}("0")),\dv{SortBool{}}("true")),\ceil{SortInt{}, Q0}(@VarI1:SortInt{})),\ceil{SortInt{}, Q0}(@VarI2:SortInt{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), anywhere{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), sortParams{}("[Q0]"), contentStartLine{}("1017"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1017,8,1017,102)"), simplification{}(), UNIQUE'Unds'ID{}("8504798d0c71a9c32788426e50147e59ac302592e16aa6bae4511370fd436af8")] + +// rule #Ceil{Int,#SortParam}(`_modInt_`(@I1,@I2))=>#And{#SortParam}(#And{#SortParam}(#Equals{Bool,#SortParam}(`_=/=Int_`(@I2,#token("0","Int")),#token("true","Bool")),#Ceil{Int,#SortParam}(@I1)),#Ceil{Int,#SortParam}(@I2)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(f864cd1e17e48500bc78b5fa83b901031cdbfd8f0575388667ce1475a2a7f532), anywhere, contentStartColumn(8), contentStartLine(1016), org.kframework.attributes.Location(Location(1016,8,1016,102)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]), simplification, sortParams([Q0])] + axiom{R,Q0} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{Q0,R} ( + \ceil{SortInt{}, Q0}(Lbl'Unds'modInt'Unds'{}(@VarI1:SortInt{},@VarI2:SortInt{})), + \and{Q0}(\and{Q0}(\equals{SortBool{}, Q0}(Lbl'UndsEqlsSlshEqls'Int'Unds'{}(@VarI2:SortInt{},\dv{SortInt{}}("0")),\dv{SortBool{}}("true")),\ceil{SortInt{}, Q0}(@VarI1:SortInt{})),\ceil{SortInt{}, Q0}(@VarI2:SortInt{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), anywhere{}(), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), sortParams{}("[Q0]"), contentStartLine{}("1016"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1016,8,1016,102)"), simplification{}(), UNIQUE'Unds'ID{}("f864cd1e17e48500bc78b5fa83b901031cdbfd8f0575388667ce1475a2a7f532")] + +// rule #Ceil{Bytes,#SortParam}(`padLeftBytes(_,_,_)_BYTES-HOOKED_Bytes_Bytes_Int_Int`(_0,LEN,VAL))=>#Equals{Bool,#SortParam}(`_andBool_`(`_andBool_`(`_<=Int_`(#token("0","Int"),LEN),`_<=Int_`(#token("0","Int"),VAL)),`_#Equals{Bool,#SortParam}(`_andBool_`(`_andBool_`(`_<=Int_`(#token("0","Int"),LEN),`_<=Int_`(#token("0","Int"),VAL)),`_#token("true","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(1e3a169a95554021c1e5a0958e5bf0d1ab9dfe4eed66cd545f6f0e151b404287), contentStartColumn(8), contentStartLine(1522), org.kframework.attributes.Location(Location(1516,8,1516,44)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'CompatibleTypes'LParUndsCommUndsRParUnds'MICHELSON'Unds'Bool'Unds'MaybeTypeName'Unds'TypeName{}(LblNoneType'Unds'MICHELSON'Unds'MaybeTypeName{}(),VarT:SortTypeName{}), + \dv{SortBool{}}("true")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1522"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1516,8,1516,44)"), UNIQUE'Unds'ID{}("1e3a169a95554021c1e5a0958e5bf0d1ab9dfe4eed66cd545f6f0e151b404287")] + +// rule `#CompatibleTypes(_,_)_MICHELSON_Bool_MaybeTypeName_TypeName`(inj{TypeName,MaybeTypeName}(T1),T2)=>`_==K_`(inj{TypeName,KItem}(T1),inj{TypeName,KItem}(T2)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(4d210f6e95813e97b794ccbf23ddce9dbb34f854c1a694d03d2bb1d29b34555d), contentStartColumn(8), contentStartLine(1523), org.kframework.attributes.Location(Location(1517,8,1517,54)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'CompatibleTypes'LParUndsCommUndsRParUnds'MICHELSON'Unds'Bool'Unds'MaybeTypeName'Unds'TypeName{}(inj{SortTypeName{}, SortMaybeTypeName{}}(VarT1:SortTypeName{}),VarT2:SortTypeName{}), + Lbl'UndsEqlsEqls'K'Unds'{}(kseq{}(inj{SortTypeName{}, SortKItem{}}(VarT1:SortTypeName{}),dotk{}()),kseq{}(inj{SortTypeName{}, SortKItem{}}(VarT2:SortTypeName{}),dotk{}()))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1523"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1517,8,1517,54)"), UNIQUE'Unds'ID{}("4d210f6e95813e97b794ccbf23ddce9dbb34f854c1a694d03d2bb1d29b34555d")] + +// rule `#ConcatBytes(_,_)_MICHELSON_Bytes_List_Bytes`(`.List`(.KList),A)=>A requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(e9fd6078e0782200d3d719b3c2c2caaf0e4b0c077c7c881db93696e8d562d829), contentStartColumn(8), contentStartLine(1285), org.kframework.attributes.Location(Location(1279,8,1279,35)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBytes{},R} ( + Lbl'Hash'ConcatBytes'LParUndsCommUndsRParUnds'MICHELSON'Unds'Bytes'Unds'List'Unds'Bytes{}(Lbl'Stop'List{}(),VarA:SortBytes{}), + VarA:SortBytes{}), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1285"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1279,8,1279,35)"), UNIQUE'Unds'ID{}("e9fd6078e0782200d3d719b3c2c2caaf0e4b0c077c7c881db93696e8d562d829")] + +// rule `#ConcatBytes(_,_)_MICHELSON_Bytes_List_Bytes`(`_List_`(`ListItem`(inj{Bytes,KItem}(B)),DL),A)=>`#ConcatBytes(_,_)_MICHELSON_Bytes_List_Bytes`(DL,`_+Bytes__BYTES-HOOKED_Bytes_Bytes_Bytes`(A,B)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(b9e55320c2af50ab2d8629d26b0c4ee4f627d49b0321ca353ba698016eacb0fd), contentStartColumn(8), contentStartLine(1286), org.kframework.attributes.Location(Location(1280,8,1280,71)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBytes{},R} ( + Lbl'Hash'ConcatBytes'LParUndsCommUndsRParUnds'MICHELSON'Unds'Bytes'Unds'List'Unds'Bytes{}(Lbl'Unds'List'Unds'{}(LblListItem{}(inj{SortBytes{}, SortKItem{}}(VarB:SortBytes{})),VarDL:SortList{}),VarA:SortBytes{}), + Lbl'Hash'ConcatBytes'LParUndsCommUndsRParUnds'MICHELSON'Unds'Bytes'Unds'List'Unds'Bytes{}(VarDL:SortList{},Lbl'UndsPlus'Bytes'UndsUnds'BYTES-HOOKED'Unds'Bytes'Unds'Bytes'Unds'Bytes{}(VarA:SortBytes{},VarB:SortBytes{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1286"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1280,8,1280,71)"), UNIQUE'Unds'ID{}("b9e55320c2af50ab2d8629d26b0c4ee4f627d49b0321ca353ba698016eacb0fd")] + +// rule `#ConcatStrings(_,_)_MICHELSON_String_List_String`(`.List`(.KList),A)=>A requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(6e2239502e609f798665ccef917d931dbcb5c027e4ce7c5686caa90122a1ef4b), contentStartColumn(8), contentStartLine(1223), org.kframework.attributes.Location(Location(1217,8,1217,37)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortString{},R} ( + Lbl'Hash'ConcatStrings'LParUndsCommUndsRParUnds'MICHELSON'Unds'String'Unds'List'Unds'String{}(Lbl'Stop'List{}(),VarA:SortString{}), + VarA:SortString{}), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1223"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1217,8,1217,37)"), UNIQUE'Unds'ID{}("6e2239502e609f798665ccef917d931dbcb5c027e4ce7c5686caa90122a1ef4b")] + +// rule `#ConcatStrings(_,_)_MICHELSON_String_List_String`(`_List_`(`ListItem`(inj{String,KItem}(S1)),DL),A)=>`#ConcatStrings(_,_)_MICHELSON_String_List_String`(DL,`_+String__STRING-COMMON_String_String_String`(A,S1)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(837b1159d700540159795abbf0cdd514f045aa44d78ca33cf28503df697fdbfb), contentStartColumn(8), contentStartLine(1224), org.kframework.attributes.Location(Location(1218,8,1218,78)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortString{},R} ( + Lbl'Hash'ConcatStrings'LParUndsCommUndsRParUnds'MICHELSON'Unds'String'Unds'List'Unds'String{}(Lbl'Unds'List'Unds'{}(LblListItem{}(inj{SortString{}, SortKItem{}}(VarS1:SortString{})),VarDL:SortList{}),VarA:SortString{}), + Lbl'Hash'ConcatStrings'LParUndsCommUndsRParUnds'MICHELSON'Unds'String'Unds'List'Unds'String{}(VarDL:SortList{},Lbl'UndsPlus'String'UndsUnds'STRING-COMMON'Unds'String'Unds'String'Unds'String{}(VarA:SortString{},VarS1:SortString{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1224"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1218,8,1218,78)"), UNIQUE'Unds'ID{}("837b1159d700540159795abbf0cdd514f045aa44d78ca33cf28503df697fdbfb")] + +// rule `#ConcreteMatch(_,_,_,_,_)_MICHELSON_Bool_Data_Type_Map_Map_Data`(ED,T,Addrs,BigMaps,AD,#Configuration)=>`#Matches(_,_)_MATCHER_Bool_Data_Data`(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Data,DataOrSeq}(ED),T,Addrs,BigMaps,#Configuration),AD) requires `notBool_`(isSymbolicData(inj{Data,KItem}(ED))) ensures #token("true","Bool") [UNIQUE_ID(e77d64b38422b94da01e950a2b18651d8adc618c3d6122ef9280b92200820925), contentStartColumn(8), contentStartLine(2109), org.kframework.attributes.Location(Location(2103,8,2104,40)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol])] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + LblnotBool'Unds'{}(LblisSymbolicData{}(kseq{}(inj{SortData{}, SortKItem{}}(VarED:SortData{}),dotk{}()))), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'ConcreteMatch'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Bool'Unds'Data'Unds'Type'Unds'Map'Unds'Map'Unds'Data{}(VarED:SortData{},VarT:SortType{},VarAddrs:SortMap{},VarBigMaps:SortMap{},VarAD:SortData{},Var'Hash'Configuration:SortGeneratedTopCell{}), + Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortData{}, SortDataOrSeq{}}(VarED:SortData{}),VarT:SortType{},VarAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}),VarAD:SortData{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("2109"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2103,8,2104,40)"), UNIQUE'Unds'ID{}("e77d64b38422b94da01e950a2b18651d8adc618c3d6122ef9280b92200820925")] + +// rule `#ConcreteMatch(_,_,_,_,_)_MICHELSON_Bool_Data_Type_Map_Map_Data`(inj{SymbolicData,Data}(S),_0,_1,_2,_3,#Configuration)=>#token("false","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(bf8d97fdc4262238431440adce09572ecd186982f529d7f9626064236c4bcedc), contentStartColumn(8), contentStartLine(2108), org.kframework.attributes.Location(Location(2102,8,2102,59)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'ConcreteMatch'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Bool'Unds'Data'Unds'Type'Unds'Map'Unds'Map'Unds'Data{}(inj{SortSymbolicData{}, SortData{}}(VarS:SortSymbolicData{}),Var'Unds'0:SortType{},Var'Unds'1:SortMap{},Var'Unds'2:SortMap{},Var'Unds'3:SortData{},Var'Hash'Configuration:SortGeneratedTopCell{}), + \dv{SortBool{}}("false")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2108"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2102,8,2102,59)"), UNIQUE'Unds'ID{}("bf8d97fdc4262238431440adce09572ecd186982f529d7f9626064236c4bcedc")] + +// rule `#ConvertBigMapsToNative(_)_MICHELSON_Map_Map`(`.Map`(.KList) #as _0,#Configuration)=>_0 requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(52b31c8c23f2beb940e974a94e4560bef5f94dde3897e6ed1f2b8fa37d6e3917), contentStartColumn(8), contentStartLine(523), org.kframework.attributes.Location(Location(523,8,523,45)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortMap{},R} ( + Lbl'Hash'ConvertBigMapsToNative'LParUndsRParUnds'MICHELSON'Unds'Map'Unds'Map{}(\and{SortMap{}}(Lbl'Stop'Map{}(),Var'Unds'0:SortMap{}),Var'Hash'Configuration:SortGeneratedTopCell{}), + Var'Unds'0:SortMap{}), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("523"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(523,8,523,45)"), UNIQUE'Unds'ID{}("52b31c8c23f2beb940e974a94e4560bef5f94dde3897e6ed1f2b8fa37d6e3917")] + +// rule `#ConvertBigMapsToNative(_)_MICHELSON_Map_Map`(`_Map_`(`_|->_`(I,`#BigMap(_,_)_MICHELSON_KItem_SequenceData_Type`(D,T)),BigMaps),#Configuration)=>`_Map_`(`_|->_`(I,inj{Data,KItem}(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{SequenceData,DataOrSeq}(D),T,`.Map`(.KList),`.Map`(.KList),#Configuration))),`#ConvertBigMapsToNative(_)_MICHELSON_Map_Map`(BigMaps,#Configuration)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(c6fa4ec3ba095aae425ef280472a52509e737d176ff622e4458fe8c89f9cc650), contentStartColumn(8), contentStartLine(524), org.kframework.attributes.Location(Location(524,8,525,82)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortMap{},R} ( + Lbl'Hash'ConvertBigMapsToNative'LParUndsRParUnds'MICHELSON'Unds'Map'Unds'Map{}(Lbl'Unds'Map'Unds'{}(Lbl'UndsPipe'-'-GT-Unds'{}(VarI:SortKItem{},Lbl'Hash'BigMap'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'SequenceData'Unds'Type{}(VarD:SortSequenceData{},VarT:SortType{})),VarBigMaps:SortMap{}),Var'Hash'Configuration:SortGeneratedTopCell{}), + Lbl'Unds'Map'Unds'{}(Lbl'UndsPipe'-'-GT-Unds'{}(VarI:SortKItem{},inj{SortData{}, SortKItem{}}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortSequenceData{}, SortDataOrSeq{}}(VarD:SortSequenceData{}),VarT:SortType{},Lbl'Stop'Map{}(),Lbl'Stop'Map{}(),Var'Hash'Configuration:SortGeneratedTopCell{}))),Lbl'Hash'ConvertBigMapsToNative'LParUndsRParUnds'MICHELSON'Unds'Map'Unds'Map{}(VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("524"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(524,8,525,82)"), UNIQUE'Unds'ID{}("c6fa4ec3ba095aae425ef280472a52509e737d176ff622e4458fe8c89f9cc650")] + +// rule `#ConvertToType(_)_MICHELSON_Type_PreType`(`#NotSet_MICHELSON-COMMON_PreType`(.KList))=>`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(`unit_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList),`.List{"___MICHELSON-COMMON-SYNTAX_AnnotationList_Annotation_AnnotationList"}_AnnotationList`(.KList)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(369c6e773c940f5b02e791618a95119c317260ad11ea7f7bb347b85e8db08b0c), contentStartColumn(8), contentStartLine(550), org.kframework.attributes.Location(Location(550,8,550,55)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortType{},R} ( + Lbl'Hash'ConvertToType'LParUndsRParUnds'MICHELSON'Unds'Type'Unds'PreType{}(Lbl'Hash'NotSet'Unds'MICHELSON-COMMON'Unds'PreType{}()), + Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(Lblunit'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(),Lbl'Stop'List'LBraQuotUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList'QuotRBraUnds'AnnotationList{}())), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("550"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(550,8,550,55)"), UNIQUE'Unds'ID{}("369c6e773c940f5b02e791618a95119c317260ad11ea7f7bb347b85e8db08b0c")] + +// rule `#ConvertToType(_)_MICHELSON_Type_PreType`(inj{Type,PreType}(T))=>T requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(dc5040643e64e42037514a800ba695a8ac0402b8f0200610bf1d63b23fa93133), contentStartColumn(8), contentStartLine(551), org.kframework.attributes.Location(Location(551,8,551,36)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortType{},R} ( + Lbl'Hash'ConvertToType'LParUndsRParUnds'MICHELSON'Unds'Type'Unds'PreType{}(inj{SortType{}, SortPreType{}}(VarT:SortType{})), + VarT:SortType{}), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("551"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(551,8,551,36)"), UNIQUE'Unds'ID{}("dc5040643e64e42037514a800ba695a8ac0402b8f0200610bf1d63b23fa93133")] + +// rule `#DefaultType(_,_)_MICHELSON_TypeName_MaybeTypeName_TypeName`(`NoneType_MICHELSON_MaybeTypeName`(.KList),T)=>T requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(c75f66f7c1a9908a9947c7973f3c1f8418d7db363ddfcfc148cee5a07e22eb8a), contentStartColumn(8), contentStartLine(1528), org.kframework.attributes.Location(Location(1522,8,1522,38)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortTypeName{},R} ( + Lbl'Hash'DefaultType'LParUndsCommUndsRParUnds'MICHELSON'Unds'TypeName'Unds'MaybeTypeName'Unds'TypeName{}(LblNoneType'Unds'MICHELSON'Unds'MaybeTypeName{}(),VarT:SortTypeName{}), + VarT:SortTypeName{}), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1528"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1522,8,1522,38)"), UNIQUE'Unds'ID{}("c75f66f7c1a9908a9947c7973f3c1f8418d7db363ddfcfc148cee5a07e22eb8a")] + +// rule `#DefaultType(_,_)_MICHELSON_TypeName_MaybeTypeName_TypeName`(inj{TypeName,MaybeTypeName}(T),_0)=>T requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(b2d82093143987be94e9e0b5bff26ec1ba2a26ed7b7d1f219c745691a0bae97a), contentStartColumn(8), contentStartLine(1527), org.kframework.attributes.Location(Location(1521,8,1521,40)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortTypeName{},R} ( + Lbl'Hash'DefaultType'LParUndsCommUndsRParUnds'MICHELSON'Unds'TypeName'Unds'MaybeTypeName'Unds'TypeName{}(inj{SortTypeName{}, SortMaybeTypeName{}}(VarT:SortTypeName{}),Var'Unds'0:SortTypeName{}), + VarT:SortTypeName{}), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1527"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1521,8,1521,40)"), UNIQUE'Unds'ID{}("b2d82093143987be94e9e0b5bff26ec1ba2a26ed7b7d1f219c745691a0bae97a")] + +// rule `#DoCompare(_,_)_MICHELSON_Int_Data_Data`(Nome,inj{OptionData,Data}(`Some__MICHELSON-COMMON-SYNTAX_OptionData_Data`(V)))=>#token("-1","Int") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(5416b4ac5207c512843ca00192df9ef7f050f088d4497976f56933b1aee5c13f), contentStartColumn(8), contentStartLine(1179), org.kframework.attributes.Location(Location(1179,8,1179,42)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortInt{},R} ( + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(VarNome:SortData{},inj{SortOptionData{}, SortData{}}(LblSome'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OptionData'Unds'Data{}(VarV:SortData{}))), + \dv{SortInt{}}("-1")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1179"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1179,8,1179,42)"), UNIQUE'Unds'ID{}("5416b4ac5207c512843ca00192df9ef7f050f088d4497976f56933b1aee5c13f")] + +// rule `#DoCompare(_,_)_MICHELSON_Int_Data_Data`(inj{Bool,Data}(#token("true","Bool") #as _1),inj{Bool,Data}(#token("false","Bool")))=>#token("1","Int") requires _1 ensures _1 [UNIQUE_ID(2ae716f0b452662cb64c52ef7e4fd48bbb65e5c61722a8dfbd7fdc8dbe2f08cb), contentStartColumn(8), contentStartLine(1168), org.kframework.attributes.Location(Location(1167,8,1167,36)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + Var'Unds'1:SortBool{}, + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortInt{},R} ( + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(inj{SortBool{}, SortData{}}(\and{SortBool{}}(\dv{SortBool{}}("true"),Var'Unds'1:SortBool{})),inj{SortBool{}, SortData{}}(\dv{SortBool{}}("false"))), + \dv{SortInt{}}("1")), + \equals{SortBool{},R}( + Var'Unds'1:SortBool{}, + \dv{SortBool{}}("true")))) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1168"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1167,8,1167,36)"), UNIQUE'Unds'ID{}("2ae716f0b452662cb64c52ef7e4fd48bbb65e5c61722a8dfbd7fdc8dbe2f08cb")] + +// rule `#DoCompare(_,_)_MICHELSON_Int_Data_Data`(inj{Bool,Data}(#token("true","Bool") #as _3),inj{Bool,Data}(#token("true","Bool") #as _3))=>#token("0","Int") requires _3 ensures _3 [UNIQUE_ID(804426e9aabdef1ec1d0aed00a8626fb9dd86e83daa1593537a7d26726480f6c), contentStartColumn(8), contentStartLine(1165), org.kframework.attributes.Location(Location(1164,8,1164,35)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + Var'Unds'3:SortBool{}, + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortInt{},R} ( + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(inj{SortBool{}, SortData{}}(\and{SortBool{}}(\dv{SortBool{}}("true"),Var'Unds'3:SortBool{})),inj{SortBool{}, SortData{}}(\and{SortBool{}}(\dv{SortBool{}}("true"),Var'Unds'3:SortBool{}))), + \dv{SortInt{}}("0")), + \equals{SortBool{},R}( + Var'Unds'3:SortBool{}, + \dv{SortBool{}}("true")))) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1165"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1164,8,1164,35)"), UNIQUE'Unds'ID{}("804426e9aabdef1ec1d0aed00a8626fb9dd86e83daa1593537a7d26726480f6c")] + +// rule `#DoCompare(_,_)_MICHELSON_Int_Data_Data`(inj{Bytes,Data}(B1),inj{Bytes,Data}(B2))=>`#DoCompare(_,_)_MICHELSON_Int_Data_Data`(inj{Int,Data}(`Bytes2Int(_,_,_)_BYTES-HOOKED_Int_Bytes_Endianness_Signedness`(B1,bigEndianBytes(.KList),unsignedBytes(.KList))),inj{Int,Data}(`Bytes2Int(_,_,_)_BYTES-HOOKED_Int_Bytes_Endianness_Signedness`(B2,bigEndianBytes(.KList),unsignedBytes(.KList)))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(03eea738b83099b3c5a54e457a066c8f34b85026e15d7a49984f1ac02e3063dd), contentStartColumn(8), contentStartLine(1187), org.kframework.attributes.Location(Location(1181,8,1181,110)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortInt{},R} ( + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(inj{SortBytes{}, SortData{}}(VarB1:SortBytes{}),inj{SortBytes{}, SortData{}}(VarB2:SortBytes{})), + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(inj{SortInt{}, SortData{}}(LblBytes2Int'LParUndsCommUndsCommUndsRParUnds'BYTES-HOOKED'Unds'Int'Unds'Bytes'Unds'Endianness'Unds'Signedness{}(VarB1:SortBytes{},LblbigEndianBytes{}(),LblunsignedBytes{}())),inj{SortInt{}, SortData{}}(LblBytes2Int'LParUndsCommUndsCommUndsRParUnds'BYTES-HOOKED'Unds'Int'Unds'Bytes'Unds'Endianness'Unds'Signedness{}(VarB2:SortBytes{},LblbigEndianBytes{}(),LblunsignedBytes{}())))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1187"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1181,8,1181,110)"), UNIQUE'Unds'ID{}("03eea738b83099b3c5a54e457a066c8f34b85026e15d7a49984f1ac02e3063dd")] + +// rule `#DoCompare(_,_)_MICHELSON_Int_Data_Data`(inj{Int,Data}(I1),inj{Int,Data}(I2))=>#token("-1","Int") requires `_#token("0","Int") requires `_==Int_`(I1,I2) ensures #token("true","Bool") [UNIQUE_ID(d740d458a72b2c100956edc49de08ad7960dbae874ccea9ad96550991db62b0e), contentStartColumn(8), contentStartLine(1171), org.kframework.attributes.Location(Location(1170,8,1170,60)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol])] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + Lbl'UndsEqlsEqls'Int'Unds'{}(VarI1:SortInt{},VarI2:SortInt{}), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortInt{},R} ( + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(inj{SortInt{}, SortData{}}(VarI1:SortInt{}),inj{SortInt{}, SortData{}}(VarI2:SortInt{})), + \dv{SortInt{}}("0")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("1171"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1170,8,1170,60)"), UNIQUE'Unds'ID{}("d740d458a72b2c100956edc49de08ad7960dbae874ccea9ad96550991db62b0e")] + +// rule `#DoCompare(_,_)_MICHELSON_Int_Data_Data`(inj{Int,Data}(I1),inj{Int,Data}(I2))=>#token("1","Int") requires `_>Int_`(I1,I2) ensures #token("true","Bool") [UNIQUE_ID(bbbf5bb9d69b5ebc060248e1d5723efc58a7e0425c0d60fb2479da64c15f5b4d), contentStartColumn(8), contentStartLine(1172), org.kframework.attributes.Location(Location(1171,8,1171,59)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol])] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + Lbl'Unds-GT-'Int'Unds'{}(VarI1:SortInt{},VarI2:SortInt{}), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortInt{},R} ( + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(inj{SortInt{}, SortData{}}(VarI1:SortInt{}),inj{SortInt{}, SortData{}}(VarI2:SortInt{})), + \dv{SortInt{}}("1")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("1172"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1171,8,1171,59)"), UNIQUE'Unds'ID{}("bbbf5bb9d69b5ebc060248e1d5723efc58a7e0425c0d60fb2479da64c15f5b4d")] + +// rule `#DoCompare(_,_)_MICHELSON_Int_Data_Data`(inj{String,Data}(S1),inj{String,Data}(S2))=>#token("-1","Int") requires `_#token("0","Int") requires `_==String__STRING-COMMON_Bool_String_String`(S1,S2) ensures #token("true","Bool") [UNIQUE_ID(fa27dbbf88186f784bd7a18d50e09008d7cf4225ebc70a19131dd8826428af46), contentStartColumn(8), contentStartLine(1175), org.kframework.attributes.Location(Location(1174,8,1174,69)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol])] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + Lbl'UndsEqlsEqls'String'UndsUnds'STRING-COMMON'Unds'Bool'Unds'String'Unds'String{}(VarS1:SortString{},VarS2:SortString{}), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortInt{},R} ( + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(inj{SortString{}, SortData{}}(VarS1:SortString{}),inj{SortString{}, SortData{}}(VarS2:SortString{})), + \dv{SortInt{}}("0")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("1175"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1174,8,1174,69)"), UNIQUE'Unds'ID{}("fa27dbbf88186f784bd7a18d50e09008d7cf4225ebc70a19131dd8826428af46")] + +// rule `#DoCompare(_,_)_MICHELSON_Int_Data_Data`(inj{String,Data}(S1),inj{String,Data}(S2))=>#token("1","Int") requires `_>String__STRING-COMMON_Bool_String_String`(S1,S2) ensures #token("true","Bool") [UNIQUE_ID(956ea1867aea0ed8c6a7209c66b86f308e7df20121a6c9a2aaf3bdc8f378610d), contentStartColumn(8), contentStartLine(1176), org.kframework.attributes.Location(Location(1175,8,1175,68)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol])] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + Lbl'Unds-GT-'String'UndsUnds'STRING-COMMON'Unds'Bool'Unds'String'Unds'String{}(VarS1:SortString{},VarS2:SortString{}), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortInt{},R} ( + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(inj{SortString{}, SortData{}}(VarS1:SortString{}),inj{SortString{}, SortData{}}(VarS2:SortString{})), + \dv{SortInt{}}("1")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("1176"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1175,8,1175,68)"), UNIQUE'Unds'ID{}("956ea1867aea0ed8c6a7209c66b86f308e7df20121a6c9a2aaf3bdc8f378610d")] + +// rule `#DoCompare(_,_)_MICHELSON_Int_Data_Data`(inj{Address,Data}(`#Address(_)_MICHELSON-COMMON_Address_String`(S1)),inj{Address,Data}(`#Address(_)_MICHELSON-COMMON_Address_String`(S2)))=>`#DoCompare(_,_)_MICHELSON_Int_Data_Data`(inj{String,Data}(S1),inj{String,Data}(S2)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(af5219ffcdbd2a1651038f7cdcf8264f55a1c0bcdfa8df722c5f8eb9edf09b2d), contentStartColumn(8), contentStartLine(1191), org.kframework.attributes.Location(Location(1185,8,1185,68)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortInt{},R} ( + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(inj{SortAddress{}, SortData{}}(Lbl'Hash'Address'LParUndsRParUnds'MICHELSON-COMMON'Unds'Address'Unds'String{}(VarS1:SortString{})),inj{SortAddress{}, SortData{}}(Lbl'Hash'Address'LParUndsRParUnds'MICHELSON-COMMON'Unds'Address'Unds'String{}(VarS2:SortString{}))), + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(inj{SortString{}, SortData{}}(VarS1:SortString{}),inj{SortString{}, SortData{}}(VarS2:SortString{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1191"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1185,8,1185,68)"), UNIQUE'Unds'ID{}("af5219ffcdbd2a1651038f7cdcf8264f55a1c0bcdfa8df722c5f8eb9edf09b2d")] + +// rule `#DoCompare(_,_)_MICHELSON_Int_Data_Data`(inj{KeyHash,Data}(`#KeyHash(_)_MICHELSON-COMMON_KeyHash_String`(S1)),inj{KeyHash,Data}(`#KeyHash(_)_MICHELSON-COMMON_KeyHash_String`(S2)))=>`#DoCompare(_,_)_MICHELSON_Int_Data_Data`(inj{String,Data}(S1),inj{String,Data}(S2)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(07f2310b11df6f27a65381edb6ac1bee33c13f138953e4c1542a016266215899), contentStartColumn(8), contentStartLine(1188), org.kframework.attributes.Location(Location(1182,8,1182,68)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortInt{},R} ( + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(inj{SortKeyHash{}, SortData{}}(Lbl'Hash'KeyHash'LParUndsRParUnds'MICHELSON-COMMON'Unds'KeyHash'Unds'String{}(VarS1:SortString{})),inj{SortKeyHash{}, SortData{}}(Lbl'Hash'KeyHash'LParUndsRParUnds'MICHELSON-COMMON'Unds'KeyHash'Unds'String{}(VarS2:SortString{}))), + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(inj{SortString{}, SortData{}}(VarS1:SortString{}),inj{SortString{}, SortData{}}(VarS2:SortString{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1188"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1182,8,1182,68)"), UNIQUE'Unds'ID{}("07f2310b11df6f27a65381edb6ac1bee33c13f138953e4c1542a016266215899")] + +// rule `#DoCompare(_,_)_MICHELSON_Int_Data_Data`(inj{Mutez,Data}(`#Mutez(_)_MICHELSON-COMMON_Mutez_Int`(I1)),inj{Mutez,Data}(`#Mutez(_)_MICHELSON-COMMON_Mutez_Int`(I2)))=>`#DoCompare(_,_)_MICHELSON_Int_Data_Data`(inj{Int,Data}(I1),inj{Int,Data}(I2)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(dbf80baedcbc00c1edc676d28f88b4b37d2501542fc80ff5e5c3913bdd3cd9af), contentStartColumn(8), contentStartLine(1189), org.kframework.attributes.Location(Location(1183,8,1183,64)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortInt{},R} ( + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(inj{SortMutez{}, SortData{}}(Lbl'Hash'Mutez'LParUndsRParUnds'MICHELSON-COMMON'Unds'Mutez'Unds'Int{}(VarI1:SortInt{})),inj{SortMutez{}, SortData{}}(Lbl'Hash'Mutez'LParUndsRParUnds'MICHELSON-COMMON'Unds'Mutez'Unds'Int{}(VarI2:SortInt{}))), + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(inj{SortInt{}, SortData{}}(VarI1:SortInt{}),inj{SortInt{}, SortData{}}(VarI2:SortInt{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1189"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1183,8,1183,64)"), UNIQUE'Unds'ID{}("dbf80baedcbc00c1edc676d28f88b4b37d2501542fc80ff5e5c3913bdd3cd9af")] + +// rule `#DoCompare(_,_)_MICHELSON_Int_Data_Data`(inj{Timestamp,Data}(`#Timestamp(_)_MICHELSON-COMMON_Timestamp_Int`(I1)),inj{Timestamp,Data}(`#Timestamp(_)_MICHELSON-COMMON_Timestamp_Int`(I2)))=>`#DoCompare(_,_)_MICHELSON_Int_Data_Data`(inj{Int,Data}(I1),inj{Int,Data}(I2)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(a3209b662884141c24466fa82fd20af99af161399f2cce2fa78b15457a161222), contentStartColumn(8), contentStartLine(1190), org.kframework.attributes.Location(Location(1184,8,1184,72)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortInt{},R} ( + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(inj{SortTimestamp{}, SortData{}}(Lbl'Hash'Timestamp'LParUndsRParUnds'MICHELSON-COMMON'Unds'Timestamp'Unds'Int{}(VarI1:SortInt{})),inj{SortTimestamp{}, SortData{}}(Lbl'Hash'Timestamp'LParUndsRParUnds'MICHELSON-COMMON'Unds'Timestamp'Unds'Int{}(VarI2:SortInt{}))), + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(inj{SortInt{}, SortData{}}(VarI1:SortInt{}),inj{SortInt{}, SortData{}}(VarI2:SortInt{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1190"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1184,8,1184,72)"), UNIQUE'Unds'ID{}("a3209b662884141c24466fa82fd20af99af161399f2cce2fa78b15457a161222")] + +// rule `#DoCompare(_,_)_MICHELSON_Int_Data_Data`(inj{OptionData,Data}(`None_MICHELSON-COMMON-SYNTAX_OptionData`(.KList)),inj{OptionData,Data}(`None_MICHELSON-COMMON-SYNTAX_OptionData`(.KList)))=>#token("0","Int") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(6753297b941a1d3d1e225645103e4d2f4646ce69629f594d1915eb9ef1e25245), contentStartColumn(8), contentStartLine(1178), org.kframework.attributes.Location(Location(1178,8,1178,42)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortInt{},R} ( + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(inj{SortOptionData{}, SortData{}}(LblNone'Unds'MICHELSON-COMMON-SYNTAX'Unds'OptionData{}()),inj{SortOptionData{}, SortData{}}(LblNone'Unds'MICHELSON-COMMON-SYNTAX'Unds'OptionData{}())), + \dv{SortInt{}}("0")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1178"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1178,8,1178,42)"), UNIQUE'Unds'ID{}("6753297b941a1d3d1e225645103e4d2f4646ce69629f594d1915eb9ef1e25245")] + +// rule `#DoCompare(_,_)_MICHELSON_Int_Data_Data`(inj{Pair,Data}(`Pair___MICHELSON-COMMON-SYNTAX_Pair_Data_Data`(A1,A2)),inj{Pair,Data}(`Pair___MICHELSON-COMMON-SYNTAX_Pair_Data_Data`(B1,B2)))=>`#DoCompare(_,_)_MICHELSON_Int_Data_Data`(A2,B2) requires `_==Int_`(`#DoCompare(_,_)_MICHELSON_Int_Data_Data`(A1,B1),#token("0","Int")) ensures #token("true","Bool") [UNIQUE_ID(7ef234a3f27cd4a85021a9c8f67e868d711f16cb8134ef8ced5fc7654846d681), contentStartColumn(8), contentStartLine(1184), org.kframework.attributes.Location(Location(1178,8,1178,104)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol])] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + Lbl'UndsEqlsEqls'Int'Unds'{}(Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(VarA1:SortData{},VarB1:SortData{}),\dv{SortInt{}}("0")), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortInt{},R} ( + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(inj{SortPair{}, SortData{}}(LblPair'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Pair'Unds'Data'Unds'Data{}(VarA1:SortData{},VarA2:SortData{})),inj{SortPair{}, SortData{}}(LblPair'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Pair'Unds'Data'Unds'Data{}(VarB1:SortData{},VarB2:SortData{}))), + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(VarA2:SortData{},VarB2:SortData{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("1184"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1178,8,1178,104)"), UNIQUE'Unds'ID{}("7ef234a3f27cd4a85021a9c8f67e868d711f16cb8134ef8ced5fc7654846d681")] + +// rule `#DoCompare(_,_)_MICHELSON_Int_Data_Data`(inj{Pair,Data}(`Pair___MICHELSON-COMMON-SYNTAX_Pair_Data_Data`(A1,A2)),inj{Pair,Data}(`Pair___MICHELSON-COMMON-SYNTAX_Pair_Data_Data`(B1,B2)))=>#token("-1","Int") requires `_==Int_`(`#DoCompare(_,_)_MICHELSON_Int_Data_Data`(A1,B1),#token("-1","Int")) ensures #token("true","Bool") [UNIQUE_ID(7badb866af1b3fc3d1ee419d5b20708b5ba44af4a2a391897dbdeb1beb32d912), contentStartColumn(8), contentStartLine(1183), org.kframework.attributes.Location(Location(1177,8,1177,105)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol])] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + Lbl'UndsEqlsEqls'Int'Unds'{}(Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(VarA1:SortData{},VarB1:SortData{}),\dv{SortInt{}}("-1")), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortInt{},R} ( + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(inj{SortPair{}, SortData{}}(LblPair'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Pair'Unds'Data'Unds'Data{}(VarA1:SortData{},VarA2:SortData{})),inj{SortPair{}, SortData{}}(LblPair'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Pair'Unds'Data'Unds'Data{}(VarB1:SortData{},VarB2:SortData{}))), + \dv{SortInt{}}("-1")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("1183"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1177,8,1177,105)"), UNIQUE'Unds'ID{}("7badb866af1b3fc3d1ee419d5b20708b5ba44af4a2a391897dbdeb1beb32d912")] + +// rule `#DoCompare(_,_)_MICHELSON_Int_Data_Data`(inj{Pair,Data}(`Pair___MICHELSON-COMMON-SYNTAX_Pair_Data_Data`(A1,A2)),inj{Pair,Data}(`Pair___MICHELSON-COMMON-SYNTAX_Pair_Data_Data`(B1,B2)))=>#token("1","Int") requires `_==Int_`(`#DoCompare(_,_)_MICHELSON_Int_Data_Data`(A1,B1),#token("1","Int")) ensures #token("true","Bool") [UNIQUE_ID(ede88656050ebd320eb4eb04e98226dc0532f9b412f07e7007f85a51b95fedec), contentStartColumn(8), contentStartLine(1185), org.kframework.attributes.Location(Location(1179,8,1179,104)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol])] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + Lbl'UndsEqlsEqls'Int'Unds'{}(Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(VarA1:SortData{},VarB1:SortData{}),\dv{SortInt{}}("1")), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortInt{},R} ( + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(inj{SortPair{}, SortData{}}(LblPair'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Pair'Unds'Data'Unds'Data{}(VarA1:SortData{},VarA2:SortData{})),inj{SortPair{}, SortData{}}(LblPair'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Pair'Unds'Data'Unds'Data{}(VarB1:SortData{},VarB2:SortData{}))), + \dv{SortInt{}}("1")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("1185"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1179,8,1179,104)"), UNIQUE'Unds'ID{}("ede88656050ebd320eb4eb04e98226dc0532f9b412f07e7007f85a51b95fedec")] + +// rule `#DoCompare(_,_)_MICHELSON_Int_Data_Data`(inj{OptionData,Data}(`Some__MICHELSON-COMMON-SYNTAX_OptionData_Data`(V)),inj{OptionData,Data}(`None_MICHELSON-COMMON-SYNTAX_OptionData`(.KList)))=>#token("1","Int") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(ac3fad9c7ec616804ba3b1574628823c89c9482417b789d9007f5ff78729ee0c), contentStartColumn(8), contentStartLine(1180), org.kframework.attributes.Location(Location(1180,8,1180,42)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortInt{},R} ( + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(inj{SortOptionData{}, SortData{}}(LblSome'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OptionData'Unds'Data{}(VarV:SortData{})),inj{SortOptionData{}, SortData{}}(LblNone'Unds'MICHELSON-COMMON-SYNTAX'Unds'OptionData{}())), + \dv{SortInt{}}("1")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1180"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1180,8,1180,42)"), UNIQUE'Unds'ID{}("ac3fad9c7ec616804ba3b1574628823c89c9482417b789d9007f5ff78729ee0c")] + +// rule `#DoCompare(_,_)_MICHELSON_Int_Data_Data`(inj{OptionData,Data}(`Some__MICHELSON-COMMON-SYNTAX_OptionData_Data`(V1)),inj{OptionData,Data}(`Some__MICHELSON-COMMON-SYNTAX_OptionData_Data`(V2)))=>`#DoCompare(_,_)_MICHELSON_Int_Data_Data`(V1,V2) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(5a0d188b3ba2914b9b1f901a7f17a020928e9de3f41193f18dc9edb6538daedf), contentStartColumn(8), contentStartLine(1181), org.kframework.attributes.Location(Location(1181,8,1181,58)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortInt{},R} ( + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(inj{SortOptionData{}, SortData{}}(LblSome'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OptionData'Unds'Data{}(VarV1:SortData{})),inj{SortOptionData{}, SortData{}}(LblSome'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OptionData'Unds'Data{}(VarV2:SortData{}))), + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(VarV1:SortData{},VarV2:SortData{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1181"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1181,8,1181,58)"), UNIQUE'Unds'ID{}("5a0d188b3ba2914b9b1f901a7f17a020928e9de3f41193f18dc9edb6538daedf")] + +// rule `#DoCompare(_,_)_MICHELSON_Int_Data_Data`(inj{Bool,Data}(#token("false","Bool")),inj{Bool,Data}(#token("true","Bool") #as _3))=>#token("-1","Int") requires _3 ensures _3 [UNIQUE_ID(bc9d8129a69f75f19bf4d356801e0e1c6b5ac4cc2ef7a6a5d4924b6fc25d93e6), contentStartColumn(8), contentStartLine(1167), org.kframework.attributes.Location(Location(1166,8,1166,37)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + Var'Unds'3:SortBool{}, + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortInt{},R} ( + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(inj{SortBool{}, SortData{}}(\dv{SortBool{}}("false")),inj{SortBool{}, SortData{}}(\and{SortBool{}}(\dv{SortBool{}}("true"),Var'Unds'3:SortBool{}))), + \dv{SortInt{}}("-1")), + \equals{SortBool{},R}( + Var'Unds'3:SortBool{}, + \dv{SortBool{}}("true")))) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1167"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1166,8,1166,37)"), UNIQUE'Unds'ID{}("bc9d8129a69f75f19bf4d356801e0e1c6b5ac4cc2ef7a6a5d4924b6fc25d93e6")] + +// rule `#DoCompare(_,_)_MICHELSON_Int_Data_Data`(inj{Bool,Data}(#token("false","Bool")),inj{Bool,Data}(#token("false","Bool")))=>#token("0","Int") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(e0d1fe664dce64b3eccf2433f0e63efcd0a6fb69cfc4f30e8d8666c02cc94cdc), contentStartColumn(8), contentStartLine(1166), org.kframework.attributes.Location(Location(1165,8,1165,37)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortInt{},R} ( + Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(inj{SortBool{}, SortData{}}(\dv{SortBool{}}("false")),inj{SortBool{}, SortData{}}(\dv{SortBool{}}("false"))), + \dv{SortInt{}}("0")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1166"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1165,8,1165,37)"), UNIQUE'Unds'ID{}("e0d1fe664dce64b3eccf2433f0e63efcd0a6fb69cfc4f30e8d8666c02cc94cdc")] + +// rule `#FailureFromMutezValue(_,_,_)_MICHELSON_FailedStack_Mutez_Int_Int`(`#Mutez(_)_MICHELSON-COMMON_Mutez_Int`(I),I1,I2)=>`(MutezOverflow__)_MICHELSON-INTERNAL-SYNTAX_FailedStack_Int_Int`(I1,I2) requires `_>=Int_`(I,`#MutezOverflowLimit_MICHELSON-COMMON_Int`(.KList)) ensures #token("true","Bool") [UNIQUE_ID(8ee6d6e91b754152a6fce21ca14d58797396431e16b66976a97fad1188ef4d22), contentStartColumn(8), contentStartLine(1839), org.kframework.attributes.Location(Location(1833,8,1834,68)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol])] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + Lbl'Unds-GT-Eqls'Int'Unds'{}(VarI:SortInt{},Lbl'Hash'MutezOverflowLimit'Unds'MICHELSON-COMMON'Unds'Int{}()), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortFailedStack{},R} ( + Lbl'Hash'FailureFromMutezValue'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'FailedStack'Unds'Mutez'Unds'Int'Unds'Int{}(Lbl'Hash'Mutez'LParUndsRParUnds'MICHELSON-COMMON'Unds'Mutez'Unds'Int{}(VarI:SortInt{}),VarI1:SortInt{},VarI2:SortInt{}), + Lbl'LPar'MutezOverflow'UndsUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'FailedStack'Unds'Int'Unds'Int{}(VarI1:SortInt{},VarI2:SortInt{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("1839"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1833,8,1834,68)"), UNIQUE'Unds'ID{}("8ee6d6e91b754152a6fce21ca14d58797396431e16b66976a97fad1188ef4d22")] + +// rule `#FailureFromMutezValue(_,_,_)_MICHELSON_FailedStack_Mutez_Int_Int`(`#Mutez(_)_MICHELSON-COMMON_Mutez_Int`(I),I1,I2)=>`(MutezUnderflow__)_MICHELSON-INTERNAL-SYNTAX_FailedStack_Int_Int`(I1,I2) requires `_`.Set`(.KList) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(da4394ffacade934f7759eaad163385cfc5141e81ab8af50374e77b1d27bf752), contentStartColumn(8), contentStartLine(2155), org.kframework.attributes.Location(Location(2149,8,2149,34)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortSet{},R} ( + Lbl'Hash'FindSymbolsB'LParUndsRParUnds'MICHELSON'Unds'Set'Unds'Block{}(inj{SortEmptyBlock{}, SortBlock{}}(Lbl'LBraRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'EmptyBlock{}())), + Lbl'Stop'Set{}()), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2155"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2149,8,2149,34)"), UNIQUE'Unds'ID{}("da4394ffacade934f7759eaad163385cfc5141e81ab8af50374e77b1d27bf752")] + +// rule `#FindSymbolsB(_)_MICHELSON_Set_Block`(`{_}_MICHELSON-COMMON-SYNTAX_Block_DataList`(`_;__MICHELSON-COMMON-SYNTAX_DataList_Data_DataList`(inj{Instruction,Data}(I),Is)))=>`_|Set__SET_Set_Set_Set`(`#FindSymbolsI(_)_MICHELSON_Set_Instruction`(I),`#FindSymbolsB(_)_MICHELSON_Set_Block`(`{_}_MICHELSON-COMMON-SYNTAX_Block_DataList`(Is))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(4937b024e9ab05ecdb73cea90083688576ea47f667b343541dd7c534487d7435), contentStartColumn(8), contentStartLine(2157), org.kframework.attributes.Location(Location(2151,8,2152,51)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortSet{},R} ( + Lbl'Hash'FindSymbolsB'LParUndsRParUnds'MICHELSON'Unds'Set'Unds'Block{}(Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Block'Unds'DataList{}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'DataList'Unds'Data'Unds'DataList{}(inj{SortInstruction{}, SortData{}}(VarI:SortInstruction{}),VarIs:SortDataList{}))), + Lbl'UndsPipe'Set'UndsUnds'SET'Unds'Set'Unds'Set'Unds'Set{}(Lbl'Hash'FindSymbolsI'LParUndsRParUnds'MICHELSON'Unds'Set'Unds'Instruction{}(VarI:SortInstruction{}),Lbl'Hash'FindSymbolsB'LParUndsRParUnds'MICHELSON'Unds'Set'Unds'Block{}(Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Block'Unds'DataList{}(VarIs:SortDataList{})))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2157"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2151,8,2152,51)"), UNIQUE'Unds'ID{}("4937b024e9ab05ecdb73cea90083688576ea47f667b343541dd7c534487d7435")] + +// rule `#FindSymbolsB(_)_MICHELSON_Set_Block`(`{_}_MICHELSON-COMMON-SYNTAX_Block_DataList`(inj{Instruction,DataList}(I)))=>`#FindSymbolsI(_)_MICHELSON_Set_Instruction`(I) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(f649f24ff60aed4a72d892c221eef66ab753be910ddad5dc2d21a78bfe1ba37b), contentStartColumn(8), contentStartLine(2156), org.kframework.attributes.Location(Location(2150,8,2150,60)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortSet{},R} ( + Lbl'Hash'FindSymbolsB'LParUndsRParUnds'MICHELSON'Unds'Set'Unds'Block{}(Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Block'Unds'DataList{}(inj{SortInstruction{}, SortDataList{}}(VarI:SortInstruction{}))), + Lbl'Hash'FindSymbolsI'LParUndsRParUnds'MICHELSON'Unds'Set'Unds'Instruction{}(VarI:SortInstruction{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2156"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2150,8,2150,60)"), UNIQUE'Unds'ID{}("f649f24ff60aed4a72d892c221eef66ab753be910ddad5dc2d21a78bfe1ba37b")] + +// rule `#FindSymbolsBL(_)_MICHELSON_Set_BlockList`(`.List{"_;__MICHELSON-INTERNAL-SYNTAX_BlockList_Block_BlockList"}_BlockList`(.KList))=>`.Set`(.KList) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(1d456e9cce7fc754bd84fc23333548b8dea148c4dda2e0b0bfce2e977e2075cc), contentStartColumn(8), contentStartLine(2150), org.kframework.attributes.Location(Location(2144,8,2144,42)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortSet{},R} ( + Lbl'Hash'FindSymbolsBL'LParUndsRParUnds'MICHELSON'Unds'Set'Unds'BlockList{}(Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockList'Unds'Block'Unds'BlockList'QuotRBraUnds'BlockList{}()), + Lbl'Stop'Set{}()), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2150"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2144,8,2144,42)"), UNIQUE'Unds'ID{}("1d456e9cce7fc754bd84fc23333548b8dea148c4dda2e0b0bfce2e977e2075cc")] + +// rule `#FindSymbolsBL(_)_MICHELSON_Set_BlockList`(`_;__MICHELSON-INTERNAL-SYNTAX_BlockList_Block_BlockList`(B,Rs))=>`_Set_`(`#FindSymbolsB(_)_MICHELSON_Set_Block`(B),`#FindSymbolsBL(_)_MICHELSON_Set_BlockList`(Rs)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(15b9ad86b113cfec2fda213a4c0bbc492fb43ff16f50e20aa4a64b6b850a2a34), contentStartColumn(8), contentStartLine(2151), org.kframework.attributes.Location(Location(2145,8,2146,43)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortSet{},R} ( + Lbl'Hash'FindSymbolsBL'LParUndsRParUnds'MICHELSON'Unds'Set'Unds'BlockList{}(Lbl'UndsSClnUndsUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockList'Unds'Block'Unds'BlockList{}(VarB:SortBlock{},VarRs:SortBlockList{})), + Lbl'Unds'Set'Unds'{}(Lbl'Hash'FindSymbolsB'LParUndsRParUnds'MICHELSON'Unds'Set'Unds'Block{}(VarB:SortBlock{}),Lbl'Hash'FindSymbolsBL'LParUndsRParUnds'MICHELSON'Unds'Set'Unds'BlockList{}(VarRs:SortBlockList{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2151"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2145,8,2146,43)"), UNIQUE'Unds'ID{}("15b9ad86b113cfec2fda213a4c0bbc492fb43ff16f50e20aa4a64b6b850a2a34")] + +// rule `#FindSymbolsI(_)_MICHELSON_Set_Instruction`(_0)=>`.Set`(.KList) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(9a4627f31188e00b6387d6d7e3b97ca4822d831b494e095b3953f4eb801c3340), contentStartColumn(8), contentStartLine(2162), org.kframework.attributes.Location(Location(2156,8,2156,41)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]), owise] + axiom{R} \implies{R} ( + \and{R} ( + \not{R} ( + \or{R} ( + \exists{R} (Var'Unds'2:SortType{}, + \exists{R} (Var'Unds'3:SortData{}, + \exists{R} (Var'Unds'1:SortAnnotationList{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortInstruction{}, R} ( + \and{SortInstruction{}} ( + Var'Unds'0:SortInstruction{}, + LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Var'Unds'1:SortAnnotationList{},Var'Unds'2:SortType{},Var'Unds'3:SortData{}) + )), + \top{R} () + ) + )))), + \bottom{R}() + ) + ), + \top{R}() + ), + \and{R} ( + \equals{SortSet{},R} ( + Lbl'Hash'FindSymbolsI'LParUndsRParUnds'MICHELSON'Unds'Set'Unds'Instruction{}(Var'Unds'0:SortInstruction{}), + Lbl'Stop'Set{}()), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2162"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2156,8,2156,41)"), owise{}(), UNIQUE'Unds'ID{}("9a4627f31188e00b6387d6d7e3b97ca4822d831b494e095b3953f4eb801c3340")] + +// rule `#FindSymbolsI(_)_MICHELSON_Set_Instruction`(`PUSH____MICHELSON-COMMON-SYNTAX_Instruction_AnnotationList_Type_Data`(_0,T,D))=>`#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(D,T) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(0ea9fc0b679a03cdd73c7862424a1ed251749aa42ff720bcce96cdc5bf640d59), contentStartColumn(8), contentStartLine(2161), org.kframework.attributes.Location(Location(2155,8,2155,57)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortSet{},R} ( + Lbl'Hash'FindSymbolsI'LParUndsRParUnds'MICHELSON'Unds'Set'Unds'Instruction{}(LblPUSH'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList'Unds'Type'Unds'Data{}(Var'Unds'0:SortAnnotationList{},VarT:SortType{},VarD:SortData{})), + Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(VarD:SortData{},VarT:SortType{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2161"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2155,8,2155,57)"), UNIQUE'Unds'ID{}("0ea9fc0b679a03cdd73c7862424a1ed251749aa42ff720bcce96cdc5bf640d59")] + +// rule `#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(inj{MapLiteral,Data}(M) #as _0,`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(inj{MapTypeName,BinaryTypeName}(`big_map_MICHELSON-COMMON-SYNTAX_MapTypeName`(.KList)),A,KT,VT))=>`#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(_0,`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(inj{MapTypeName,BinaryTypeName}(`map_MICHELSON-COMMON-SYNTAX_MapTypeName`(.KList)),A,KT,VT)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(56c00654c061ce3b664dafc3d1819792ab9d3cea6bbda9226a1ba13a9b3bab48), contentStartColumn(8), contentStartLine(2198), org.kframework.attributes.Location(Location(2192,8,2193,38)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortSet{},R} ( + Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(\and{SortData{}}(inj{SortMapLiteral{}, SortData{}}(VarM:SortMapLiteral{}),Var'Unds'0:SortData{}),Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(inj{SortMapTypeName{}, SortBinaryTypeName{}}(Lblbig'Unds'map'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}()),VarA:SortAnnotationList{},VarKT:SortType{},VarVT:SortType{})), + Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(Var'Unds'0:SortData{},Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(inj{SortMapTypeName{}, SortBinaryTypeName{}}(Lblmap'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}()),VarA:SortAnnotationList{},VarKT:SortType{},VarVT:SortType{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2198"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2192,8,2193,38)"), UNIQUE'Unds'ID{}("56c00654c061ce3b664dafc3d1819792ab9d3cea6bbda9226a1ba13a9b3bab48")] + +// rule `#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(_0,_1)=>`.Set`(.KList) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(1dfcd63670a9d22d705c9fa4a6f71532d113d8dfc68d208c1e84de8ef71c272e), contentStartColumn(8), contentStartLine(2201), org.kframework.attributes.Location(Location(2195,8,2195,36)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]), owise] + axiom{R} \implies{R} ( + \and{R} ( + \not{R} ( + \or{R} ( + \exists{R} (Var'Unds'2:SortData{}, + \exists{R} (Var'Unds'3:SortAnnotationList{}, + \exists{R} (Var'Unds'5:SortType{}, + \exists{R} (Var'Unds'4:SortType{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + Var'Unds'0:SortData{}, + inj{SortOrData{}, SortData{}}(LblLeft'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(Var'Unds'2:SortData{})) + )),\and{R} ( + \ceil{SortType{}, R} ( + \and{SortType{}} ( + Var'Unds'1:SortType{}, + Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(Lblor'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}(),Var'Unds'3:SortAnnotationList{},Var'Unds'4:SortType{},Var'Unds'5:SortType{}) + )), + \top{R} () + )) + ))))), + \or{R} ( + \exists{R} (Var'Unds'8:SortAnnotationList{}, + \exists{R} (Var'Unds'6:SortData{}, + \exists{R} (Var'Unds'7:SortData{}, + \exists{R} (Var'Unds'10:SortType{}, + \exists{R} (Var'Unds'9:SortType{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + Var'Unds'0:SortData{}, + inj{SortPair{}, SortData{}}(LblPair'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Pair'Unds'Data'Unds'Data{}(Var'Unds'6:SortData{},Var'Unds'7:SortData{})) + )),\and{R} ( + \ceil{SortType{}, R} ( + \and{SortType{}} ( + Var'Unds'1:SortType{}, + Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(Lblpair'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}(),Var'Unds'8:SortAnnotationList{},Var'Unds'9:SortType{},Var'Unds'10:SortType{}) + )), + \top{R} () + )) + )))))), + \or{R} ( + \exists{R} (Var'Unds'13:SortAnnotationList{}, + \exists{R} (Var'Unds'11:SortMapLiteral{}, + \exists{R} (Var'Unds'12:SortData{}, + \exists{R} (Var'Unds'15:SortType{}, + \exists{R} (Var'Unds'14:SortType{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + Var'Unds'0:SortData{}, + \and{SortData{}}(inj{SortMapLiteral{}, SortData{}}(Var'Unds'11:SortMapLiteral{}),Var'Unds'12:SortData{}) + )),\and{R} ( + \ceil{SortType{}, R} ( + \and{SortType{}} ( + Var'Unds'1:SortType{}, + Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(inj{SortMapTypeName{}, SortBinaryTypeName{}}(Lblbig'Unds'map'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}()),Var'Unds'13:SortAnnotationList{},Var'Unds'14:SortType{},Var'Unds'15:SortType{}) + )), + \top{R} () + )) + )))))), + \or{R} ( + \exists{R} (Var'Unds'18:SortAnnotationList{}, + \exists{R} (Var'Unds'17:SortDataList{}, + \exists{R} (Var'Unds'16:SortData{}, + \exists{R} (Var'Unds'19:SortType{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + Var'Unds'0:SortData{}, + inj{SortBlock{}, SortData{}}(Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Block'Unds'DataList{}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'DataList'Unds'Data'Unds'DataList{}(Var'Unds'16:SortData{},Var'Unds'17:SortDataList{}))) + )),\and{R} ( + \ceil{SortType{}, R} ( + \and{SortType{}} ( + Var'Unds'1:SortType{}, + Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Lbllist'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'18:SortAnnotationList{},Var'Unds'19:SortType{}) + )), + \top{R} () + )) + ))))), + \or{R} ( + \exists{R} (Var'Unds'22:SortType{}, + \exists{R} (Var'Unds'21:SortAnnotationList{}, + \exists{R} (Var'Unds'20:SortData{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + Var'Unds'0:SortData{}, + inj{SortOptionData{}, SortData{}}(LblSome'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OptionData'Unds'Data{}(Var'Unds'20:SortData{})) + )),\and{R} ( + \ceil{SortType{}, R} ( + \and{SortType{}} ( + Var'Unds'1:SortType{}, + Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Lbloption'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'21:SortAnnotationList{},Var'Unds'22:SortType{}) + )), + \top{R} () + )) + )))), + \or{R} ( + \exists{R} (Var'Unds'24:SortDataList{}, + \exists{R} (Var'Unds'23:SortData{}, + \exists{R} (Var'Unds'26:SortType{}, + \exists{R} (Var'Unds'25:SortAnnotationList{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + Var'Unds'0:SortData{}, + inj{SortBlock{}, SortData{}}(Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Block'Unds'DataList{}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'DataList'Unds'Data'Unds'DataList{}(Var'Unds'23:SortData{},Var'Unds'24:SortDataList{}))) + )),\and{R} ( + \ceil{SortType{}, R} ( + \and{SortType{}} ( + Var'Unds'1:SortType{}, + Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Lblset'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'25:SortAnnotationList{},Var'Unds'26:SortType{}) + )), + \top{R} () + )) + ))))), + \or{R} ( + \exists{R} (Var'Unds'29:SortType{}, + \exists{R} (Var'Unds'28:SortAnnotationList{}, + \exists{R} (Var'Unds'27:SortData{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + Var'Unds'0:SortData{}, + inj{SortBlock{}, SortData{}}(Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Block'Unds'DataList{}(inj{SortData{}, SortDataList{}}(Var'Unds'27:SortData{}))) + )),\and{R} ( + \ceil{SortType{}, R} ( + \and{SortType{}} ( + Var'Unds'1:SortType{}, + Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Lbllist'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'28:SortAnnotationList{},Var'Unds'29:SortType{}) + )), + \top{R} () + )) + )))), + \or{R} ( + \exists{R} (Var'Unds'30:SortSymbolicData{}, + \exists{R} (Var'Unds'31:SortType{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + Var'Unds'0:SortData{}, + inj{SortSymbolicData{}, SortData{}}(Var'Unds'30:SortSymbolicData{}) + )),\and{R} ( + \ceil{SortType{}, R} ( + \and{SortType{}} ( + Var'Unds'1:SortType{}, + Var'Unds'31:SortType{} + )), + \top{R} () + )) + ))), + \or{R} ( + \exists{R} (Var'Unds'35:SortType{}, + \exists{R} (Var'Unds'33:SortMapEntryList{}, + \exists{R} (Var'Unds'34:SortAnnotationList{}, + \exists{R} (Var'Unds'32:SortMapEntry{}, + \exists{R} (Var'Unds'37:SortType{}, + \exists{R} (Var'Unds'36:SortType{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + Var'Unds'0:SortData{}, + inj{SortMapLiteral{}, SortData{}}(Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'MapLiteral'Unds'MapEntryList{}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'MapEntryList'Unds'MapEntry'Unds'MapEntryList{}(Var'Unds'32:SortMapEntry{},Var'Unds'33:SortMapEntryList{}))) + )),\and{R} ( + \ceil{SortType{}, R} ( + \and{SortType{}} ( + Var'Unds'1:SortType{}, + \and{SortType{}}(Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(inj{SortMapTypeName{}, SortBinaryTypeName{}}(Lblmap'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}()),Var'Unds'34:SortAnnotationList{},Var'Unds'35:SortType{},Var'Unds'36:SortType{}),Var'Unds'37:SortType{}) + )), + \top{R} () + )) + ))))))), + \or{R} ( + \exists{R} (Var'Unds'39:SortType{}, + \exists{R} (Var'Unds'38:SortAnnotationList{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + Var'Unds'0:SortData{}, + inj{SortEmptyBlock{}, SortData{}}(Lbl'LBraRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'EmptyBlock{}()) + )),\and{R} ( + \ceil{SortType{}, R} ( + \and{SortType{}} ( + Var'Unds'1:SortType{}, + Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Lblset'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'38:SortAnnotationList{},Var'Unds'39:SortType{}) + )), + \top{R} () + )) + ))), + \or{R} ( + \exists{R} (Var'Unds'40:SortAnnotationList{}, + \exists{R} (Var'Unds'41:SortType{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + Var'Unds'0:SortData{}, + inj{SortEmptyBlock{}, SortData{}}(Lbl'LBraRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'EmptyBlock{}()) + )),\and{R} ( + \ceil{SortType{}, R} ( + \and{SortType{}} ( + Var'Unds'1:SortType{}, + Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Lbllist'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'40:SortAnnotationList{},Var'Unds'41:SortType{}) + )), + \top{R} () + )) + ))), + \or{R} ( + \exists{R} (Var'Unds'46:SortType{}, + \exists{R} (Var'Unds'44:SortData{}, + \exists{R} (Var'Unds'45:SortAnnotationList{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + Var'Unds'0:SortData{}, + inj{SortBlock{}, SortData{}}(Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Block'Unds'DataList{}(inj{SortData{}, SortDataList{}}(Var'Unds'44:SortData{}))) + )),\and{R} ( + \ceil{SortType{}, R} ( + \and{SortType{}} ( + Var'Unds'1:SortType{}, + Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Lblset'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'45:SortAnnotationList{},Var'Unds'46:SortType{}) + )), + \top{R} () + )) + )))), + \or{R} ( + \exists{R} (Var'Unds'50:SortType{}, + \exists{R} (Var'Unds'48:SortAnnotationList{}, + \exists{R} (Var'Unds'49:SortType{}, + \exists{R} (Var'Unds'47:SortData{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + Var'Unds'0:SortData{}, + inj{SortOrData{}, SortData{}}(LblRight'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(Var'Unds'47:SortData{})) + )),\and{R} ( + \ceil{SortType{}, R} ( + \and{SortType{}} ( + Var'Unds'1:SortType{}, + Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(Lblor'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}(),Var'Unds'48:SortAnnotationList{},Var'Unds'49:SortType{},Var'Unds'50:SortType{}) + )), + \top{R} () + )) + ))))), + \or{R} ( + \exists{R} (Var'Unds'51:SortData{}, + \exists{R} (Var'Unds'52:SortData{}, + \exists{R} (Var'Unds'55:SortType{}, + \exists{R} (Var'Unds'54:SortType{}, + \exists{R} (Var'Unds'53:SortAnnotationList{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + Var'Unds'0:SortData{}, + inj{SortMapLiteral{}, SortData{}}(Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'MapLiteral'Unds'MapEntryList{}(inj{SortMapEntry{}, SortMapEntryList{}}(LblElt'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'MapEntry'Unds'Data'Unds'Data{}(Var'Unds'51:SortData{},Var'Unds'52:SortData{})))) + )),\and{R} ( + \ceil{SortType{}, R} ( + \and{SortType{}} ( + Var'Unds'1:SortType{}, + Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(inj{SortMapTypeName{}, SortBinaryTypeName{}}(Lblmap'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}()),Var'Unds'53:SortAnnotationList{},Var'Unds'54:SortType{},Var'Unds'55:SortType{}) + )), + \top{R} () + )) + )))))), + \or{R} ( + \exists{R} (Var'Unds'57:SortType{}, + \exists{R} (Var'Unds'56:SortAnnotationList{}, + \exists{R} (Var'Unds'58:SortType{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + Var'Unds'0:SortData{}, + inj{SortEmptyBlock{}, SortData{}}(Lbl'LBraRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'EmptyBlock{}()) + )),\and{R} ( + \ceil{SortType{}, R} ( + \and{SortType{}} ( + Var'Unds'1:SortType{}, + Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(inj{SortMapTypeName{}, SortBinaryTypeName{}}(Lblmap'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}()),Var'Unds'56:SortAnnotationList{},Var'Unds'57:SortType{},Var'Unds'58:SortType{}) + )), + \top{R} () + )) + )))), + \or{R} ( + \exists{R} (Var'Unds'62:SortType{}, + \exists{R} (Var'Unds'61:SortType{}, + \exists{R} (Var'Unds'59:SortBlock{}, + \exists{R} (Var'Unds'60:SortAnnotationList{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + Var'Unds'0:SortData{}, + inj{SortBlock{}, SortData{}}(Var'Unds'59:SortBlock{}) + )),\and{R} ( + \ceil{SortType{}, R} ( + \and{SortType{}} ( + Var'Unds'1:SortType{}, + Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(Lbllambda'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}(),Var'Unds'60:SortAnnotationList{},Var'Unds'61:SortType{},Var'Unds'62:SortType{}) + )), + \top{R} () + )) + ))))), + \bottom{R}() + )))))))))))))))) + ), + \top{R}() + ), + \and{R} ( + \equals{SortSet{},R} ( + Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(Var'Unds'0:SortData{},Var'Unds'1:SortType{}), + Lbl'Stop'Set{}()), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2201"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2195,8,2195,36)"), owise{}(), UNIQUE'Unds'ID{}("1dfcd63670a9d22d705c9fa4a6f71532d113d8dfc68d208c1e84de8ef71c272e")] + +// rule `#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(inj{Block,Data}(B),`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(`lambda_MICHELSON-COMMON-SYNTAX_BinaryTypeName`(.KList),_0,_1,_2))=>`#FindSymbolsB(_)_MICHELSON_Set_Block`(B) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(1f51bd6528708050123b334448e01d19856a482dca4354d1a96147da3e40cff7), contentStartColumn(8), contentStartLine(2180), org.kframework.attributes.Location(Location(2174,8,2174,65)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortSet{},R} ( + Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(inj{SortBlock{}, SortData{}}(VarB:SortBlock{}),Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(Lbllambda'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}(),Var'Unds'0:SortAnnotationList{},Var'Unds'1:SortType{},Var'Unds'2:SortType{})), + Lbl'Hash'FindSymbolsB'LParUndsRParUnds'MICHELSON'Unds'Set'Unds'Block{}(VarB:SortBlock{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2180"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2174,8,2174,65)"), UNIQUE'Unds'ID{}("1f51bd6528708050123b334448e01d19856a482dca4354d1a96147da3e40cff7")] + +// rule `#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(inj{SymbolicData,Data}(S),T)=>`SetItem`(inj{SymbolicElement,KItem}(`#SymbolicElement(_,_)_MICHELSON_SymbolicElement_SymbolicData_Type`(S,T))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(72aca4c89c2e4eb287d0baf78d9c3967783d8294aa88d8bc070dfbea3f51c3b0), contentStartColumn(8), contentStartLine(2172), org.kframework.attributes.Location(Location(2166,8,2167,39)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortSet{},R} ( + Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(inj{SortSymbolicData{}, SortData{}}(VarS:SortSymbolicData{}),VarT:SortType{}), + LblSetItem{}(inj{SortSymbolicElement{}, SortKItem{}}(Lbl'Hash'SymbolicElement'LParUndsCommUndsRParUnds'MICHELSON'Unds'SymbolicElement'Unds'SymbolicData'Unds'Type{}(VarS:SortSymbolicData{},VarT:SortType{})))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2172"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2166,8,2167,39)"), UNIQUE'Unds'ID{}("72aca4c89c2e4eb287d0baf78d9c3967783d8294aa88d8bc070dfbea3f51c3b0")] + +// rule `#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(inj{OrData,Data}(`Left__MICHELSON-COMMON-SYNTAX_OrData_Data`(V)),`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(`or_MICHELSON-COMMON-SYNTAX_BinaryTypeName`(.KList),_0,T,_1))=>`#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(V,T) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(a6a518346a1f1743ecf7525db1e53907c928776af7cde776557470c217d96ad7), contentStartColumn(8), contentStartLine(2178), org.kframework.attributes.Location(Location(2172,8,2172,64)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortSet{},R} ( + Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(inj{SortOrData{}, SortData{}}(LblLeft'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(VarV:SortData{})),Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(Lblor'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}(),Var'Unds'0:SortAnnotationList{},VarT:SortType{},Var'Unds'1:SortType{})), + Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(VarV:SortData{},VarT:SortType{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2178"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2172,8,2172,64)"), UNIQUE'Unds'ID{}("a6a518346a1f1743ecf7525db1e53907c928776af7cde776557470c217d96ad7")] + +// rule `#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(inj{Pair,Data}(`Pair___MICHELSON-COMMON-SYNTAX_Pair_Data_Data`(V1,V2)),`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(`pair_MICHELSON-COMMON-SYNTAX_BinaryTypeName`(.KList),_0,T1,T2))=>`_|Set__SET_Set_Set_Set`(`#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(V1,T1),`#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(V2,T2)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(8e6cea59eae33f7492b7c24178f95b7f17e7b924fe8f0ace291098b318c79396), contentStartColumn(8), contentStartLine(2175), org.kframework.attributes.Location(Location(2169,8,2170,58)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortSet{},R} ( + Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(inj{SortPair{}, SortData{}}(LblPair'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Pair'Unds'Data'Unds'Data{}(VarV1:SortData{},VarV2:SortData{})),Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(Lblpair'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}(),Var'Unds'0:SortAnnotationList{},VarT1:SortType{},VarT2:SortType{})), + Lbl'UndsPipe'Set'UndsUnds'SET'Unds'Set'Unds'Set'Unds'Set{}(Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(VarV1:SortData{},VarT1:SortType{}),Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(VarV2:SortData{},VarT2:SortType{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2175"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2169,8,2170,58)"), UNIQUE'Unds'ID{}("8e6cea59eae33f7492b7c24178f95b7f17e7b924fe8f0ace291098b318c79396")] + +// rule `#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(inj{OrData,Data}(`Right__MICHELSON-COMMON-SYNTAX_OrData_Data`(V)),`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(`or_MICHELSON-COMMON-SYNTAX_BinaryTypeName`(.KList),_0,_1,T))=>`#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(V,T) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(7df0d0b7249c1a15a30a2ae50632dcf7177b0fd1f8348a6002d4a618eae317ab), contentStartColumn(8), contentStartLine(2179), org.kframework.attributes.Location(Location(2173,8,2173,65)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortSet{},R} ( + Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(inj{SortOrData{}, SortData{}}(LblRight'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(VarV:SortData{})),Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(Lblor'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}(),Var'Unds'0:SortAnnotationList{},Var'Unds'1:SortType{},VarT:SortType{})), + Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(VarV:SortData{},VarT:SortType{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2179"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2173,8,2173,65)"), UNIQUE'Unds'ID{}("7df0d0b7249c1a15a30a2ae50632dcf7177b0fd1f8348a6002d4a618eae317ab")] + +// rule `#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(inj{OptionData,Data}(`Some__MICHELSON-COMMON-SYNTAX_OptionData_Data`(V)),`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(`option_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList),_0,T))=>`#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(V,T) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(b4cbf66cb60000a2424fb6eb13ec35e3af122c2d13c73335265efb0c37969a77), contentStartColumn(8), contentStartLine(2177), org.kframework.attributes.Location(Location(2171,8,2171,66)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortSet{},R} ( + Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(inj{SortOptionData{}, SortData{}}(LblSome'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OptionData'Unds'Data{}(VarV:SortData{})),Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Lbloption'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'0:SortAnnotationList{},VarT:SortType{})), + Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(VarV:SortData{},VarT:SortType{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2177"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2171,8,2171,66)"), UNIQUE'Unds'ID{}("b4cbf66cb60000a2424fb6eb13ec35e3af122c2d13c73335265efb0c37969a77")] + +// rule `#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(inj{Block,Data}(`{_}_MICHELSON-COMMON-SYNTAX_Block_DataList`(`_;__MICHELSON-COMMON-SYNTAX_DataList_Data_DataList`(D,DL))),`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(`list_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList),_0,T))=>`_|Set__SET_Set_Set_Set`(`#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(D,T),`#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(inj{Block,Data}(`{_}_MICHELSON-COMMON-SYNTAX_Block_DataList`(DL)),T)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(7e05ab9ed3c68830df562bf6e7a61379260ba5c47f60e4abd2887d4e2b3f38d6), contentStartColumn(8), contentStartLine(2184), org.kframework.attributes.Location(Location(2178,8,2179,59)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortSet{},R} ( + Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(inj{SortBlock{}, SortData{}}(Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Block'Unds'DataList{}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'DataList'Unds'Data'Unds'DataList{}(VarD:SortData{},VarDL:SortDataList{}))),Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Lbllist'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'0:SortAnnotationList{},VarT:SortType{})), + Lbl'UndsPipe'Set'UndsUnds'SET'Unds'Set'Unds'Set'Unds'Set{}(Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(VarD:SortData{},VarT:SortType{}),Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(inj{SortBlock{}, SortData{}}(Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Block'Unds'DataList{}(VarDL:SortDataList{})),VarT:SortType{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2184"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2178,8,2179,59)"), UNIQUE'Unds'ID{}("7e05ab9ed3c68830df562bf6e7a61379260ba5c47f60e4abd2887d4e2b3f38d6")] + +// rule `#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(inj{Block,Data}(`{_}_MICHELSON-COMMON-SYNTAX_Block_DataList`(`_;__MICHELSON-COMMON-SYNTAX_DataList_Data_DataList`(D,DL))),`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(`set_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList),_0,T))=>`_|Set__SET_Set_Set_Set`(`#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(D,T),`#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(inj{Block,Data}(`{_}_MICHELSON-COMMON-SYNTAX_Block_DataList`(DL)),T)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(c083ae0849b03bbccaf70f92adf8c2b7cca0d74d8b14d1722ef13f16a28b8396), contentStartColumn(8), contentStartLine(2189), org.kframework.attributes.Location(Location(2183,8,2184,59)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortSet{},R} ( + Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(inj{SortBlock{}, SortData{}}(Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Block'Unds'DataList{}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'DataList'Unds'Data'Unds'DataList{}(VarD:SortData{},VarDL:SortDataList{}))),Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Lblset'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'0:SortAnnotationList{},VarT:SortType{})), + Lbl'UndsPipe'Set'UndsUnds'SET'Unds'Set'Unds'Set'Unds'Set{}(Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(VarD:SortData{},VarT:SortType{}),Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(inj{SortBlock{}, SortData{}}(Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Block'Unds'DataList{}(VarDL:SortDataList{})),VarT:SortType{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2189"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2183,8,2184,59)"), UNIQUE'Unds'ID{}("c083ae0849b03bbccaf70f92adf8c2b7cca0d74d8b14d1722ef13f16a28b8396")] + +// rule `#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(inj{Block,Data}(`{_}_MICHELSON-COMMON-SYNTAX_Block_DataList`(inj{Data,DataList}(D))),`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(`list_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList),_0,T))=>`#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(D,T) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(f8cd761185705d21abd592b4ba0a76a2feb7e9e392e57fa4cd2c857eaa71a594), contentStartColumn(8), contentStartLine(2183), org.kframework.attributes.Location(Location(2177,8,2177,68)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortSet{},R} ( + Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(inj{SortBlock{}, SortData{}}(Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Block'Unds'DataList{}(inj{SortData{}, SortDataList{}}(VarD:SortData{}))),Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Lbllist'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'0:SortAnnotationList{},VarT:SortType{})), + Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(VarD:SortData{},VarT:SortType{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2183"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2177,8,2177,68)"), UNIQUE'Unds'ID{}("f8cd761185705d21abd592b4ba0a76a2feb7e9e392e57fa4cd2c857eaa71a594")] + +// rule `#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(inj{Block,Data}(`{_}_MICHELSON-COMMON-SYNTAX_Block_DataList`(inj{Data,DataList}(D))),`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(`set_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList),_0,T))=>`#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(D,T) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(0551572154ae466a26606465a623b15a63834282e88f6417466a470932bb5fe9), contentStartColumn(8), contentStartLine(2188), org.kframework.attributes.Location(Location(2182,8,2182,67)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortSet{},R} ( + Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(inj{SortBlock{}, SortData{}}(Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Block'Unds'DataList{}(inj{SortData{}, SortDataList{}}(VarD:SortData{}))),Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Lblset'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'0:SortAnnotationList{},VarT:SortType{})), + Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(VarD:SortData{},VarT:SortType{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2188"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2182,8,2182,67)"), UNIQUE'Unds'ID{}("0551572154ae466a26606465a623b15a63834282e88f6417466a470932bb5fe9")] + +// rule `#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(inj{MapLiteral,Data}(`{_}_MICHELSON-COMMON-SYNTAX_MapLiteral_MapEntryList`(`_;__MICHELSON-COMMON-SYNTAX_MapEntryList_MapEntry_MapEntryList`(M,ML))),`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(inj{MapTypeName,BinaryTypeName}(`map_MICHELSON-COMMON-SYNTAX_MapTypeName`(.KList)),_0,_1,_2) #as MT)=>`_|Set__SET_Set_Set_Set`(`#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(inj{MapLiteral,Data}(`{_}_MICHELSON-COMMON-SYNTAX_MapLiteral_MapEntryList`(inj{MapEntry,MapEntryList}(M))),MT),`#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(inj{MapLiteral,Data}(`{_}_MICHELSON-COMMON-SYNTAX_MapLiteral_MapEntryList`(ML)),MT)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(6b57fb64fd532dbf08a495cfd90d1b3cdf9a7daa2e3ac14009e009a3bff60345), contentStartColumn(8), contentStartLine(2195), org.kframework.attributes.Location(Location(2189,8,2190,65)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortSet{},R} ( + Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(inj{SortMapLiteral{}, SortData{}}(Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'MapLiteral'Unds'MapEntryList{}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'MapEntryList'Unds'MapEntry'Unds'MapEntryList{}(VarM:SortMapEntry{},VarML:SortMapEntryList{}))),\and{SortType{}}(Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(inj{SortMapTypeName{}, SortBinaryTypeName{}}(Lblmap'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}()),Var'Unds'0:SortAnnotationList{},Var'Unds'1:SortType{},Var'Unds'2:SortType{}),VarMT:SortType{})), + Lbl'UndsPipe'Set'UndsUnds'SET'Unds'Set'Unds'Set'Unds'Set{}(Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(inj{SortMapLiteral{}, SortData{}}(Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'MapLiteral'Unds'MapEntryList{}(inj{SortMapEntry{}, SortMapEntryList{}}(VarM:SortMapEntry{}))),VarMT:SortType{}),Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(inj{SortMapLiteral{}, SortData{}}(Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'MapLiteral'Unds'MapEntryList{}(VarML:SortMapEntryList{})),VarMT:SortType{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2195"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2189,8,2190,65)"), UNIQUE'Unds'ID{}("6b57fb64fd532dbf08a495cfd90d1b3cdf9a7daa2e3ac14009e009a3bff60345")] + +// rule `#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(inj{MapLiteral,Data}(`{_}_MICHELSON-COMMON-SYNTAX_MapLiteral_MapEntryList`(inj{MapEntry,MapEntryList}(`Elt___MICHELSON-COMMON-SYNTAX_MapEntry_Data_Data`(K,V)))),`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(inj{MapTypeName,BinaryTypeName}(`map_MICHELSON-COMMON-SYNTAX_MapTypeName`(.KList)),_0,KT,VT))=>`_|Set__SET_Set_Set_Set`(`#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(K,KT),`#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(V,VT)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(02089cfd3822459695f56718e21603858144fde86489a918f98db3a0c4308e83), contentStartColumn(8), contentStartLine(2193), org.kframework.attributes.Location(Location(2187,8,2188,56)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortSet{},R} ( + Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(inj{SortMapLiteral{}, SortData{}}(Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'MapLiteral'Unds'MapEntryList{}(inj{SortMapEntry{}, SortMapEntryList{}}(LblElt'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'MapEntry'Unds'Data'Unds'Data{}(VarK:SortData{},VarV:SortData{})))),Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(inj{SortMapTypeName{}, SortBinaryTypeName{}}(Lblmap'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}()),Var'Unds'0:SortAnnotationList{},VarKT:SortType{},VarVT:SortType{})), + Lbl'UndsPipe'Set'UndsUnds'SET'Unds'Set'Unds'Set'Unds'Set{}(Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(VarK:SortData{},VarKT:SortType{}),Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(VarV:SortData{},VarVT:SortType{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2193"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2187,8,2188,56)"), UNIQUE'Unds'ID{}("02089cfd3822459695f56718e21603858144fde86489a918f98db3a0c4308e83")] + +// rule `#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(inj{EmptyBlock,Data}(`{}_MICHELSON-COMMON-SYNTAX_EmptyBlock`(.KList)),`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(`list_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList),_0,_1))=>`.Set`(.KList) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(05db0be7179452afdfe3e93ad07cfe1c7f5fb817144c28dd79bb6eedc8d4c683), contentStartColumn(8), contentStartLine(2182), org.kframework.attributes.Location(Location(2176,8,2176,45)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortSet{},R} ( + Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(inj{SortEmptyBlock{}, SortData{}}(Lbl'LBraRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'EmptyBlock{}()),Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Lbllist'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'0:SortAnnotationList{},Var'Unds'1:SortType{})), + Lbl'Stop'Set{}()), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2182"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2176,8,2176,45)"), UNIQUE'Unds'ID{}("05db0be7179452afdfe3e93ad07cfe1c7f5fb817144c28dd79bb6eedc8d4c683")] + +// rule `#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(inj{EmptyBlock,Data}(`{}_MICHELSON-COMMON-SYNTAX_EmptyBlock`(.KList)),`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(`set_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList),_0,_1))=>`.Set`(.KList) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(b90ac6d581cdcd4a7fffe1310583b8e727ad3934d871a7e58f54cf55530d951c), contentStartColumn(8), contentStartLine(2187), org.kframework.attributes.Location(Location(2181,8,2181,44)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortSet{},R} ( + Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(inj{SortEmptyBlock{}, SortData{}}(Lbl'LBraRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'EmptyBlock{}()),Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Lblset'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'0:SortAnnotationList{},Var'Unds'1:SortType{})), + Lbl'Stop'Set{}()), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2187"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2181,8,2181,44)"), UNIQUE'Unds'ID{}("b90ac6d581cdcd4a7fffe1310583b8e727ad3934d871a7e58f54cf55530d951c")] + +// rule `#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(inj{EmptyBlock,Data}(`{}_MICHELSON-COMMON-SYNTAX_EmptyBlock`(.KList)),`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(inj{MapTypeName,BinaryTypeName}(`map_MICHELSON-COMMON-SYNTAX_MapTypeName`(.KList)),_0,_1,_2))=>`.Set`(.KList) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(b39b07a68c72863e61f920b882d891f161904cf09f512e0df7b430436e080601), contentStartColumn(8), contentStartLine(2192), org.kframework.attributes.Location(Location(2186,8,2186,46)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortSet{},R} ( + Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(inj{SortEmptyBlock{}, SortData{}}(Lbl'LBraRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'EmptyBlock{}()),Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(inj{SortMapTypeName{}, SortBinaryTypeName{}}(Lblmap'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}()),Var'Unds'0:SortAnnotationList{},Var'Unds'1:SortType{},Var'Unds'2:SortType{})), + Lbl'Stop'Set{}()), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2192"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2186,8,2186,46)"), UNIQUE'Unds'ID{}("b39b07a68c72863e61f920b882d891f161904cf09f512e0df7b430436e080601")] + +// rule `#FindSymbolsS(_)_MICHELSON_Set_StackElementList`(`.List{"_;__UNIT-TEST-COMMON-SYNTAX_StackElementList_StackElementLiteral_StackElementList"}_StackElementList`(.KList))=>`.Set`(.KList) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(2ad868c9d8e5e301a27838586f730e3c6ca0ddef8a4c9a38ffd08bfd411de16b), contentStartColumn(8), contentStartLine(2165), org.kframework.attributes.Location(Location(2159,8,2159,48)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortSet{},R} ( + Lbl'Hash'FindSymbolsS'LParUndsRParUnds'MICHELSON'Unds'Set'Unds'StackElementList{}(Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'StackElementList'Unds'StackElementLiteral'Unds'StackElementList'QuotRBraUnds'StackElementList{}()), + Lbl'Stop'Set{}()), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2165"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2159,8,2159,48)"), UNIQUE'Unds'ID{}("2ad868c9d8e5e301a27838586f730e3c6ca0ddef8a4c9a38ffd08bfd411de16b")] + +// rule `#FindSymbolsS(_)_MICHELSON_Set_StackElementList`(`_;__UNIT-TEST-COMMON-SYNTAX_StackElementList_StackElementLiteral_StackElementList`(`Stack_elt___UNIT-TEST-COMMON-SYNTAX_StackElementLiteral_Type_Data`(T,D),Ss))=>`_|Set__SET_Set_Set_Set`(`#FindSymbolsIn(_,_)_MICHELSON_Set_Data_Type`(D,T),`#FindSymbolsS(_)_MICHELSON_Set_StackElementList`(Ss)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(06f5c8b94330c4b01efda5dee381b36f6b3a642a6fafe0c164fcd7a07e9f039e), contentStartColumn(8), contentStartLine(2166), org.kframework.attributes.Location(Location(2160,8,2161,51)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortSet{},R} ( + Lbl'Hash'FindSymbolsS'LParUndsRParUnds'MICHELSON'Unds'Set'Unds'StackElementList{}(Lbl'UndsSClnUndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'StackElementList'Unds'StackElementLiteral'Unds'StackElementList{}(LblStack'Unds'elt'UndsUndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'StackElementLiteral'Unds'Type'Unds'Data{}(VarT:SortType{},VarD:SortData{}),VarSs:SortStackElementList{})), + Lbl'UndsPipe'Set'UndsUnds'SET'Unds'Set'Unds'Set'Unds'Set{}(Lbl'Hash'FindSymbolsIn'LParUndsCommUndsRParUnds'MICHELSON'Unds'Set'Unds'Data'Unds'Type{}(VarD:SortData{},VarT:SortType{}),Lbl'Hash'FindSymbolsS'LParUndsRParUnds'MICHELSON'Unds'Set'Unds'StackElementList{}(VarSs:SortStackElementList{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2166"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2160,8,2161,51)"), UNIQUE'Unds'ID{}("06f5c8b94330c4b01efda5dee381b36f6b3a642a6fafe0c164fcd7a07e9f039e")] + +// rule `#IsComparable(_)_MICHELSON_Bool_TypeName`(NumberType)=>#token("true","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(e60e754a3affb6018cabf7b1da038eb8e46e54f0d8c38a1aca84e6532dfeebb2), contentStartColumn(8), contentStartLine(1129), org.kframework.attributes.Location(Location(1129,8,1129,41)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'IsComparable'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName{}(VarNumberType:SortTypeName{}), + \dv{SortBool{}}("true")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1129"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1129,8,1129,41)"), UNIQUE'Unds'ID{}("e60e754a3affb6018cabf7b1da038eb8e46e54f0d8c38a1aca84e6532dfeebb2")] + +// rule `#IsComparable(_)_MICHELSON_Bool_TypeName`(`___MICHELSON-COMMON_TypeName_UnaryTypeName_TypeName`(`contract_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList),_0))=>#token("false","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(8a8a157e56932547c08d4c54e6f9fd38ed26669c3e9dd3d7aabd284bd5cd40d7), contentStartColumn(8), contentStartLine(1151), org.kframework.attributes.Location(Location(1150,8,1150,42)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'IsComparable'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName{}(Lbl'UndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'UnaryTypeName'Unds'TypeName{}(Lblcontract'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'0:SortTypeName{})), + \dv{SortBool{}}("false")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1151"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1150,8,1150,42)"), UNIQUE'Unds'ID{}("8a8a157e56932547c08d4c54e6f9fd38ed26669c3e9dd3d7aabd284bd5cd40d7")] + +// rule `#IsComparable(_)_MICHELSON_Bool_TypeName`(`___MICHELSON-COMMON_TypeName_UnaryTypeName_TypeName`(`list_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList),_0))=>#token("false","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(923fe6d2f5aad5c063b97ae18cea2126370ad7f7c3b48b4f58ce93903433b2f0), contentStartColumn(8), contentStartLine(1149), org.kframework.attributes.Location(Location(1148,8,1148,38)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'IsComparable'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName{}(Lbl'UndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'UnaryTypeName'Unds'TypeName{}(Lbllist'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'0:SortTypeName{})), + \dv{SortBool{}}("false")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1149"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1148,8,1148,38)"), UNIQUE'Unds'ID{}("923fe6d2f5aad5c063b97ae18cea2126370ad7f7c3b48b4f58ce93903433b2f0")] + +// rule `#IsComparable(_)_MICHELSON_Bool_TypeName`(`___MICHELSON-COMMON_TypeName_UnaryTypeName_TypeName`(`option_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList),_0))=>#token("true","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(796696e8d3dda25d0c5af0e51776d17eab1c490058baf226a6906ac41a31ba7d), contentStartColumn(8), contentStartLine(1139), org.kframework.attributes.Location(Location(1139,8,1139,39)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'IsComparable'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName{}(Lbl'UndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'UnaryTypeName'Unds'TypeName{}(Lbloption'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'0:SortTypeName{})), + \dv{SortBool{}}("true")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1139"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1139,8,1139,39)"), UNIQUE'Unds'ID{}("796696e8d3dda25d0c5af0e51776d17eab1c490058baf226a6906ac41a31ba7d")] + +// rule `#IsComparable(_)_MICHELSON_Bool_TypeName`(`___MICHELSON-COMMON_TypeName_UnaryTypeName_TypeName`(`set_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList),_0))=>#token("false","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(3e2886490d63c267d52fb0e33218decbbc74fd750eca8511d372588366b154bb), contentStartColumn(8), contentStartLine(1150), org.kframework.attributes.Location(Location(1149,8,1149,37)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'IsComparable'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName{}(Lbl'UndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'UnaryTypeName'Unds'TypeName{}(Lblset'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'0:SortTypeName{})), + \dv{SortBool{}}("false")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1150"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1149,8,1149,37)"), UNIQUE'Unds'ID{}("3e2886490d63c267d52fb0e33218decbbc74fd750eca8511d372588366b154bb")] + +// rule `#IsComparable(_)_MICHELSON_Bool_TypeName`(`____MICHELSON-COMMON_TypeName_BinaryTypeName_TypeName_TypeName`(inj{MapTypeName,BinaryTypeName}(`big_map_MICHELSON-COMMON-SYNTAX_MapTypeName`(.KList)),_0,_1))=>#token("false","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(3fb2ee65a9884b261a2cd9b1fee48c37bcaa63479a8cf00cd2c67bda0a7eedc4), contentStartColumn(8), contentStartLine(1157), org.kframework.attributes.Location(Location(1156,8,1156,43)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'IsComparable'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName{}(Lbl'UndsUndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'BinaryTypeName'Unds'TypeName'Unds'TypeName{}(inj{SortMapTypeName{}, SortBinaryTypeName{}}(Lblbig'Unds'map'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}()),Var'Unds'0:SortTypeName{},Var'Unds'1:SortTypeName{})), + \dv{SortBool{}}("false")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1157"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1156,8,1156,43)"), UNIQUE'Unds'ID{}("3fb2ee65a9884b261a2cd9b1fee48c37bcaa63479a8cf00cd2c67bda0a7eedc4")] + +// rule `#IsComparable(_)_MICHELSON_Bool_TypeName`(`____MICHELSON-COMMON_TypeName_BinaryTypeName_TypeName_TypeName`(inj{MapTypeName,BinaryTypeName}(`map_MICHELSON-COMMON-SYNTAX_MapTypeName`(.KList)),_0,_1))=>#token("false","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(f15a7c99b28b066b91040f95ee8f318e2a929b98c455e444a1a6ada9184b7ad8), contentStartColumn(8), contentStartLine(1156), org.kframework.attributes.Location(Location(1155,8,1155,39)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'IsComparable'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName{}(Lbl'UndsUndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'BinaryTypeName'Unds'TypeName'Unds'TypeName{}(inj{SortMapTypeName{}, SortBinaryTypeName{}}(Lblmap'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}()),Var'Unds'0:SortTypeName{},Var'Unds'1:SortTypeName{})), + \dv{SortBool{}}("false")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1156"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1155,8,1155,39)"), UNIQUE'Unds'ID{}("f15a7c99b28b066b91040f95ee8f318e2a929b98c455e444a1a6ada9184b7ad8")] + +// rule `#IsComparable(_)_MICHELSON_Bool_TypeName`(`____MICHELSON-COMMON_TypeName_BinaryTypeName_TypeName_TypeName`(`lambda_MICHELSON-COMMON-SYNTAX_BinaryTypeName`(.KList),_0,_1))=>#token("false","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(af69afb7507ce35edff38612c678095e3c5cc4c290a37d20faf331617e61f95d), contentStartColumn(8), contentStartLine(1155), org.kframework.attributes.Location(Location(1154,8,1154,42)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'IsComparable'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName{}(Lbl'UndsUndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'BinaryTypeName'Unds'TypeName'Unds'TypeName{}(Lbllambda'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}(),Var'Unds'0:SortTypeName{},Var'Unds'1:SortTypeName{})), + \dv{SortBool{}}("false")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1155"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1154,8,1154,42)"), UNIQUE'Unds'ID{}("af69afb7507ce35edff38612c678095e3c5cc4c290a37d20faf331617e61f95d")] + +// rule `#IsComparable(_)_MICHELSON_Bool_TypeName`(`____MICHELSON-COMMON_TypeName_BinaryTypeName_TypeName_TypeName`(`or_MICHELSON-COMMON-SYNTAX_BinaryTypeName`(.KList),_0,_1))=>#token("false","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(c39b9d828e5c1abe1ee090e2374659cd6ae362c789c9c3b19ab6cbbc4ebf99c2), contentStartColumn(8), contentStartLine(1154), org.kframework.attributes.Location(Location(1153,8,1153,38)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'IsComparable'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName{}(Lbl'UndsUndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'BinaryTypeName'Unds'TypeName'Unds'TypeName{}(Lblor'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}(),Var'Unds'0:SortTypeName{},Var'Unds'1:SortTypeName{})), + \dv{SortBool{}}("false")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1154"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1153,8,1153,38)"), UNIQUE'Unds'ID{}("c39b9d828e5c1abe1ee090e2374659cd6ae362c789c9c3b19ab6cbbc4ebf99c2")] + +// rule `#IsComparable(_)_MICHELSON_Bool_TypeName`(`____MICHELSON-COMMON_TypeName_BinaryTypeName_TypeName_TypeName`(`pair_MICHELSON-COMMON-SYNTAX_BinaryTypeName`(.KList),T1,T2))=>`_andBool_`(`#IsComparable(_)_MICHELSON_Bool_TypeName`(T1),`#IsComparable(_)_MICHELSON_Bool_TypeName`(T2)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(e4b478fec1c03032976e4d899404503510425a8b2c61f5ea474a7e2c74904a7b), contentStartColumn(8), contentStartLine(1137), org.kframework.attributes.Location(Location(1137,8,1137,80)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'IsComparable'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName{}(Lbl'UndsUndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'BinaryTypeName'Unds'TypeName'Unds'TypeName{}(Lblpair'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}(),VarT1:SortTypeName{},VarT2:SortTypeName{})), + Lbl'Unds'andBool'Unds'{}(Lbl'Hash'IsComparable'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName{}(VarT1:SortTypeName{}),Lbl'Hash'IsComparable'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName{}(VarT2:SortTypeName{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1137"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1137,8,1137,80)"), UNIQUE'Unds'ID{}("e4b478fec1c03032976e4d899404503510425a8b2c61f5ea474a7e2c74904a7b")] + +// rule `#IsComparable(_)_MICHELSON_Bool_TypeName`(inj{NullaryTypeName,TypeName}(`address_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList)))=>#token("true","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(286a7eaf057dbd2a57347d9bb425adb396cffb12c86cc4b5cd6a1a31087bb54e), contentStartColumn(8), contentStartLine(1136), org.kframework.attributes.Location(Location(1136,8,1136,38)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'IsComparable'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName{}(inj{SortNullaryTypeName{}, SortTypeName{}}(Lbladdress'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())), + \dv{SortBool{}}("true")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1136"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1136,8,1136,38)"), UNIQUE'Unds'ID{}("286a7eaf057dbd2a57347d9bb425adb396cffb12c86cc4b5cd6a1a31087bb54e")] + +// rule `#IsComparable(_)_MICHELSON_Bool_TypeName`(inj{NullaryTypeName,TypeName}(`bool_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList)))=>#token("true","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(da4c3f545441c20beda94984ba185172412efa6f519c96226c0f27b5276ef73d), contentStartColumn(8), contentStartLine(1133), org.kframework.attributes.Location(Location(1133,8,1133,35)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'IsComparable'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName{}(inj{SortNullaryTypeName{}, SortTypeName{}}(Lblbool'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())), + \dv{SortBool{}}("true")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1133"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1133,8,1133,35)"), UNIQUE'Unds'ID{}("da4c3f545441c20beda94984ba185172412efa6f519c96226c0f27b5276ef73d")] + +// rule `#IsComparable(_)_MICHELSON_Bool_TypeName`(inj{NullaryTypeName,TypeName}(`bytes_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList)))=>#token("true","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(4d089d3130e1d7e3b174824fd96064298ad831e80d5eff74997ee6b3219e899f), contentStartColumn(8), contentStartLine(1131), org.kframework.attributes.Location(Location(1131,8,1131,36)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'IsComparable'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName{}(inj{SortNullaryTypeName{}, SortTypeName{}}(Lblbytes'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())), + \dv{SortBool{}}("true")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1131"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1131,8,1131,36)"), UNIQUE'Unds'ID{}("4d089d3130e1d7e3b174824fd96064298ad831e80d5eff74997ee6b3219e899f")] + +// rule `#IsComparable(_)_MICHELSON_Bool_TypeName`(inj{NullaryTypeName,TypeName}(`chain_id_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList)))=>#token("false","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(d5eb8a5c732f6861a5ce5e0e0d0dcf73de088b878a5bb3752872f97c26e3ee35), contentStartColumn(8), contentStartLine(1146), org.kframework.attributes.Location(Location(1144,8,1144,40)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'IsComparable'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName{}(inj{SortNullaryTypeName{}, SortTypeName{}}(Lblchain'Unds'id'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())), + \dv{SortBool{}}("false")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1146"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1144,8,1144,40)"), UNIQUE'Unds'ID{}("d5eb8a5c732f6861a5ce5e0e0d0dcf73de088b878a5bb3752872f97c26e3ee35")] + +// rule `#IsComparable(_)_MICHELSON_Bool_TypeName`(inj{NullaryTypeName,TypeName}(`key_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList)))=>#token("false","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(977235341a6abbd45454bd6c7f90b0b5fd0e621294175e7474b4bbbcacec736a), contentStartColumn(8), contentStartLine(1142), org.kframework.attributes.Location(Location(1140,8,1140,35)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'IsComparable'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName{}(inj{SortNullaryTypeName{}, SortTypeName{}}(Lblkey'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())), + \dv{SortBool{}}("false")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1142"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1140,8,1140,35)"), UNIQUE'Unds'ID{}("977235341a6abbd45454bd6c7f90b0b5fd0e621294175e7474b4bbbcacec736a")] + +// rule `#IsComparable(_)_MICHELSON_Bool_TypeName`(inj{NullaryTypeName,TypeName}(`key_hash_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList)))=>#token("true","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(5099438858137bd3efddb0e87467c6509c05e0410c0ccbe4bcf088060e78d42e), contentStartColumn(8), contentStartLine(1134), org.kframework.attributes.Location(Location(1134,8,1134,39)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'IsComparable'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName{}(inj{SortNullaryTypeName{}, SortTypeName{}}(Lblkey'Unds'hash'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())), + \dv{SortBool{}}("true")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1134"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1134,8,1134,39)"), UNIQUE'Unds'ID{}("5099438858137bd3efddb0e87467c6509c05e0410c0ccbe4bcf088060e78d42e")] + +// rule `#IsComparable(_)_MICHELSON_Bool_TypeName`(inj{NullaryTypeName,TypeName}(`mutez_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList)))=>#token("true","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(ba959a1069f20f9770225c8085549be231dc565b09a74a9f703f86ed68840133), contentStartColumn(8), contentStartLine(1132), org.kframework.attributes.Location(Location(1132,8,1132,36)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'IsComparable'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName{}(inj{SortNullaryTypeName{}, SortTypeName{}}(Lblmutez'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())), + \dv{SortBool{}}("true")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1132"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1132,8,1132,36)"), UNIQUE'Unds'ID{}("ba959a1069f20f9770225c8085549be231dc565b09a74a9f703f86ed68840133")] + +// rule `#IsComparable(_)_MICHELSON_Bool_TypeName`(inj{NullaryTypeName,TypeName}(`operation_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList)))=>#token("false","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(c1ab2222183e007b9061214f1509b93b10dd9aa2e4e230be1dfa05ee723a0eed), contentStartColumn(8), contentStartLine(1145), org.kframework.attributes.Location(Location(1143,8,1143,41)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'IsComparable'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName{}(inj{SortNullaryTypeName{}, SortTypeName{}}(Lbloperation'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())), + \dv{SortBool{}}("false")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1145"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1143,8,1143,41)"), UNIQUE'Unds'ID{}("c1ab2222183e007b9061214f1509b93b10dd9aa2e4e230be1dfa05ee723a0eed")] + +// rule `#IsComparable(_)_MICHELSON_Bool_TypeName`(inj{NullaryTypeName,TypeName}(`signature_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList)))=>#token("false","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(a6da81452e959f23d7d44eab739f396486116b0696cb9d8371c9f21cdc2b66b0), contentStartColumn(8), contentStartLine(1144), org.kframework.attributes.Location(Location(1142,8,1142,41)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'IsComparable'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName{}(inj{SortNullaryTypeName{}, SortTypeName{}}(Lblsignature'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())), + \dv{SortBool{}}("false")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1144"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1142,8,1142,41)"), UNIQUE'Unds'ID{}("a6da81452e959f23d7d44eab739f396486116b0696cb9d8371c9f21cdc2b66b0")] + +// rule `#IsComparable(_)_MICHELSON_Bool_TypeName`(inj{NullaryTypeName,TypeName}(`string_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList)))=>#token("true","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(2b0726b15fcf3fd3a42973f885561debbb8e13d8cdad002b9d93f1d2bcbbbb30), contentStartColumn(8), contentStartLine(1130), org.kframework.attributes.Location(Location(1130,8,1130,37)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'IsComparable'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName{}(inj{SortNullaryTypeName{}, SortTypeName{}}(Lblstring'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())), + \dv{SortBool{}}("true")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1130"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1130,8,1130,37)"), UNIQUE'Unds'ID{}("2b0726b15fcf3fd3a42973f885561debbb8e13d8cdad002b9d93f1d2bcbbbb30")] + +// rule `#IsComparable(_)_MICHELSON_Bool_TypeName`(inj{NullaryTypeName,TypeName}(`timestamp_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList)))=>#token("true","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(c1a3e24a7ad1dc936cd45172d7065470e301edfe3f17b4e59a135dd85560d41c), contentStartColumn(8), contentStartLine(1135), org.kframework.attributes.Location(Location(1135,8,1135,40)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'IsComparable'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName{}(inj{SortNullaryTypeName{}, SortTypeName{}}(Lbltimestamp'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())), + \dv{SortBool{}}("true")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1135"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1135,8,1135,40)"), UNIQUE'Unds'ID{}("c1a3e24a7ad1dc936cd45172d7065470e301edfe3f17b4e59a135dd85560d41c")] + +// rule `#IsComparable(_)_MICHELSON_Bool_TypeName`(inj{NullaryTypeName,TypeName}(`unit_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList)))=>#token("false","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(d47c16414813479133f7366249d748c7e37330c8fc5ddb0987bab31fc8650677), contentStartColumn(8), contentStartLine(1143), org.kframework.attributes.Location(Location(1141,8,1141,36)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'IsComparable'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName{}(inj{SortNullaryTypeName{}, SortTypeName{}}(Lblunit'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}())), + \dv{SortBool{}}("false")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1143"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1141,8,1141,36)"), UNIQUE'Unds'ID{}("d47c16414813479133f7366249d748c7e37330c8fc5ddb0987bab31fc8650677")] + +// rule `#IsLegalMutezValue(_)_MICHELSON-COMMON_Bool_Int`(I)=>`_andBool_`(`_>=Int_`(I,#token("0","Int")),`_inj{FailedStack,InternalStack}(FS) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(a634d2f9575f0700f48ae5158e76be61d45566b7fbd351523c15a2417e824fd2), contentStartColumn(8), contentStartLine(43), org.kframework.attributes.Location(Location(43,8,43,50)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortInternalStack{},R} ( + Lbl'Hash'LiteralStackToStack'LParUndsRParUnds'MICHELSON-COMMON'Unds'InternalStack'Unds'OutputStack{}(inj{SortFailedStack{}, SortOutputStack{}}(VarFS:SortFailedStack{})), + inj{SortFailedStack{}, SortInternalStack{}}(VarFS:SortFailedStack{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("43"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(43,8,43,50)"), UNIQUE'Unds'ID{}("a634d2f9575f0700f48ae5158e76be61d45566b7fbd351523c15a2417e824fd2")] + +// rule `#LiteralStackToStack(_)_MICHELSON-COMMON_InternalStack_OutputStack`(inj{LiteralStack,OutputStack}(`{_}_UNIT-TEST-COMMON-SYNTAX_LiteralStack_StackElementList`(LS)))=>inj{Stack,InternalStack}(`#LiteralStackToStack(_,_)_MICHELSON-COMMON_Stack_StackElementList_Stack`(LS,`.List{"_;__MICHELSON-COMMON_Stack_StackElement_Stack"}_Stack`(.KList))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(84b741ffc8e9415160326e7f41d514672d637ae918b0a3a03d93cbb54d971fd2), contentStartColumn(8), contentStartLine(44), org.kframework.attributes.Location(Location(44,8,44,72)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortInternalStack{},R} ( + Lbl'Hash'LiteralStackToStack'LParUndsRParUnds'MICHELSON-COMMON'Unds'InternalStack'Unds'OutputStack{}(inj{SortLiteralStack{}, SortOutputStack{}}(Lbl'LBraUndsRBraUnds'UNIT-TEST-COMMON-SYNTAX'Unds'LiteralStack'Unds'StackElementList{}(VarLS:SortStackElementList{}))), + inj{SortStack{}, SortInternalStack{}}(Lbl'Hash'LiteralStackToStack'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElementList'Unds'Stack{}(VarLS:SortStackElementList{},Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack'QuotRBraUnds'Stack{}()))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("44"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(44,8,44,72)"), UNIQUE'Unds'ID{}("84b741ffc8e9415160326e7f41d514672d637ae918b0a3a03d93cbb54d971fd2")] + +// rule `#LiteralStackToStack(_,_)_MICHELSON-COMMON_Stack_StackElementList_Stack`(`.List{"_;__UNIT-TEST-COMMON-SYNTAX_StackElementList_StackElementLiteral_StackElementList"}_StackElementList`(.KList),SS)=>`reverseStack(_)_MICHELSON-COMMON_Stack_Stack`(SS) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(3a3e06404b7634615b13df21774ce9f76e27ce9ae6d97d40a7eca83f80c71f82), contentStartColumn(8), contentStartLine(46), org.kframework.attributes.Location(Location(46,8,46,71)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortStack{},R} ( + Lbl'Hash'LiteralStackToStack'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElementList'Unds'Stack{}(Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'StackElementList'Unds'StackElementLiteral'Unds'StackElementList'QuotRBraUnds'StackElementList{}(),VarSS:SortStack{}), + LblreverseStack'LParUndsRParUnds'MICHELSON-COMMON'Unds'Stack'Unds'Stack{}(VarSS:SortStack{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("46"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(46,8,46,71)"), UNIQUE'Unds'ID{}("3a3e06404b7634615b13df21774ce9f76e27ce9ae6d97d40a7eca83f80c71f82")] + +// rule `#LiteralStackToStack(_,_)_MICHELSON-COMMON_Stack_StackElementList_Stack`(`_;__UNIT-TEST-COMMON-SYNTAX_StackElementList_StackElementLiteral_StackElementList`(`Stack_elt___UNIT-TEST-COMMON-SYNTAX_StackElementLiteral_Type_Data`(T,D),LS),SS)=>`#LiteralStackToStack(_,_)_MICHELSON-COMMON_Stack_StackElementList_Stack`(LS,`_;__MICHELSON-COMMON_Stack_StackElement_Stack`(`[__]_MICHELSON-COMMON_StackElement_TypeName_Data`(`#Name(_)_MICHELSON-COMMON_TypeName_Type`(T),D),SS)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(93b5474a0f414e71e37bbcda409b8db87425d4982b409372be44acd3cc22c61b), contentStartColumn(8), contentStartLine(45), org.kframework.attributes.Location(Location(45,8,45,99)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortStack{},R} ( + Lbl'Hash'LiteralStackToStack'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElementList'Unds'Stack{}(Lbl'UndsSClnUndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'StackElementList'Unds'StackElementLiteral'Unds'StackElementList{}(LblStack'Unds'elt'UndsUndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'StackElementLiteral'Unds'Type'Unds'Data{}(VarT:SortType{},VarD:SortData{}),VarLS:SortStackElementList{}),VarSS:SortStack{}), + Lbl'Hash'LiteralStackToStack'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElementList'Unds'Stack{}(VarLS:SortStackElementList{},Lbl'UndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack{}(Lbl'LSqBUndsUndsRSqBUnds'MICHELSON-COMMON'Unds'StackElement'Unds'TypeName'Unds'Data{}(Lbl'Hash'Name'LParUndsRParUnds'MICHELSON-COMMON'Unds'TypeName'Unds'Type{}(VarT:SortType{}),VarD:SortData{}),VarSS:SortStack{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("45"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(45,8,45,99)"), UNIQUE'Unds'ID{}("93b5474a0f414e71e37bbcda409b8db87425d4982b409372be44acd3cc22c61b")] + +// rule `#Matches(_,_)_MATCHER_Bool_Data_Data`(D1,D2)=>`_==K_`(inj{Data,KItem}(D1),inj{Data,KItem}(D2)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(edb00babc7085ec7338499a0c57df6fb841b3e581bb8d771c4f245c6e1012284), contentStartColumn(8), contentStartLine(2381), org.kframework.attributes.Location(Location(2344,8,2344,37)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]), owise] + axiom{R} \implies{R} ( + \and{R} ( + \not{R} ( + \or{R} ( + \exists{R} (Var'Unds'2:SortInt{}, + \exists{R} (Var'Unds'3:SortOptionData{}, + \exists{R} (Var'Unds'1:SortOptionData{}, + \exists{R} (Var'Unds'0:SortInt{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD1:SortData{}, + inj{SortBlockchainOperation{}, SortData{}}(LblSet'Unds'delegate'LParUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'OptionData{}(Var'Unds'0:SortInt{},Var'Unds'1:SortOptionData{})) + )),\and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD2:SortData{}, + inj{SortBlockchainOperation{}, SortData{}}(LblSet'Unds'delegate'LParUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'OptionData{}(Var'Unds'2:SortInt{},Var'Unds'3:SortOptionData{})) + )), + \top{R} () + )) + ))))), + \or{R} ( + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD1:SortData{}, + inj{SortList{}, SortData{}}(Lbl'Stop'List{}()) + )),\and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD2:SortData{}, + inj{SortList{}, SortData{}}(Lbl'Stop'List{}()) + )), + \top{R} () + )) + ), + \or{R} ( + \exists{R} (Var'Unds'5:SortData{}, + \exists{R} (Var'Unds'4:SortData{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD1:SortData{}, + inj{SortOrData{}, SortData{}}(LblRight'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(Var'Unds'4:SortData{})) + )),\and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD2:SortData{}, + inj{SortOrData{}, SortData{}}(LblRight'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(Var'Unds'5:SortData{})) + )), + \top{R} () + )) + ))), + \or{R} ( + \exists{R} (Var'Unds'8:SortMutez{}, + \exists{R} (Var'Unds'13:SortAddress{}, + \exists{R} (Var'Unds'6:SortInt{}, + \exists{R} (Var'Unds'11:SortData{}, + \exists{R} (Var'Unds'7:SortData{}, + \exists{R} (Var'Unds'12:SortMutez{}, + \exists{R} (Var'Unds'10:SortInt{}, + \exists{R} (Var'Unds'9:SortAddress{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD1:SortData{}, + inj{SortBlockchainOperation{}, SortData{}}(LblTransfer'Unds'tokens'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Data'Unds'Mutez'Unds'Address{}(Var'Unds'6:SortInt{},Var'Unds'7:SortData{},Var'Unds'8:SortMutez{},Var'Unds'9:SortAddress{})) + )),\and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD2:SortData{}, + inj{SortBlockchainOperation{}, SortData{}}(LblTransfer'Unds'tokens'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Data'Unds'Mutez'Unds'Address{}(Var'Unds'10:SortInt{},Var'Unds'11:SortData{},Var'Unds'12:SortMutez{},Var'Unds'13:SortAddress{})) + )), + \top{R} () + )) + ))))))))), + \or{R} ( + \exists{R} (Var'Unds'14:SortData{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD1:SortData{}, + Lbl'Hash'Any'Unds'UNIT-TEST-COMMON-SYNTAX'Unds'Data{}() + )),\and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD2:SortData{}, + Var'Unds'14:SortData{} + )), + \top{R} () + )) + )), + \or{R} ( + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD1:SortData{}, + inj{SortSet{}, SortData{}}(Lbl'Stop'Set{}()) + )),\and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD2:SortData{}, + inj{SortSet{}, SortData{}}(Lbl'Stop'Set{}()) + )), + \top{R} () + )) + ), + \or{R} ( + \exists{R} (Var'Unds'18:SortMutez{}, + \exists{R} (Var'Unds'22:SortMutez{}, + \exists{R} (Var'Unds'23:SortData{}, + \exists{R} (Var'Unds'17:SortOptionData{}, + \exists{R} (Var'Unds'21:SortOptionData{}, + \exists{R} (Var'Unds'15:SortInt{}, + \exists{R} (Var'Unds'16:SortContract{}, + \exists{R} (Var'Unds'19:SortData{}, + \exists{R} (Var'Unds'20:SortInt{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD1:SortData{}, + inj{SortBlockchainOperation{}, SortData{}}(LblCreate'Unds'contract'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Contract'Unds'OptionData'Unds'Mutez'Unds'Data{}(Var'Unds'15:SortInt{},Var'Unds'16:SortContract{},Var'Unds'17:SortOptionData{},Var'Unds'18:SortMutez{},Var'Unds'19:SortData{})) + )),\and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD2:SortData{}, + inj{SortBlockchainOperation{}, SortData{}}(LblCreate'Unds'contract'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Contract'Unds'OptionData'Unds'Mutez'Unds'Data{}(Var'Unds'20:SortInt{},Var'Unds'16:SortContract{},Var'Unds'21:SortOptionData{},Var'Unds'22:SortMutez{},Var'Unds'23:SortData{})) + )), + \top{R} () + )) + )))))))))), + \or{R} ( + \exists{R} (Var'Unds'24:SortKItem{}, + \exists{R} (Var'Unds'28:SortMap{}, + \exists{R} (Var'Unds'26:SortMap{}, + \exists{R} (Var'Unds'27:SortData{}, + \exists{R} (Var'Unds'25:SortData{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD1:SortData{}, + inj{SortMap{}, SortData{}}(Lbl'Unds'Map'Unds'{}(Lbl'UndsPipe'-'-GT-Unds'{}(Var'Unds'24:SortKItem{},inj{SortData{}, SortKItem{}}(Var'Unds'25:SortData{})),Var'Unds'26:SortMap{})) + )),\and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD2:SortData{}, + inj{SortMap{}, SortData{}}(Lbl'Unds'Map'Unds'{}(Lbl'UndsPipe'-'-GT-Unds'{}(Var'Unds'24:SortKItem{},inj{SortData{}, SortKItem{}}(Var'Unds'27:SortData{})),Var'Unds'28:SortMap{})) + )), + \top{R} () + )) + )))))), + \or{R} ( + \exists{R} (Var'Unds'29:SortData{}, + \exists{R} (Var'Unds'30:SortData{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD1:SortData{}, + inj{SortOrData{}, SortData{}}(LblLeft'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(Var'Unds'29:SortData{})) + )),\and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD2:SortData{}, + inj{SortOrData{}, SortData{}}(LblLeft'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(Var'Unds'30:SortData{})) + )), + \top{R} () + )) + ))), + \or{R} ( + \exists{R} (Var'Unds'33:SortData{}, + \exists{R} (Var'Unds'34:SortData{}, + \exists{R} (Var'Unds'32:SortData{}, + \exists{R} (Var'Unds'31:SortData{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD1:SortData{}, + inj{SortPair{}, SortData{}}(LblPair'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Pair'Unds'Data'Unds'Data{}(Var'Unds'31:SortData{},Var'Unds'32:SortData{})) + )),\and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD2:SortData{}, + inj{SortPair{}, SortData{}}(LblPair'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Pair'Unds'Data'Unds'Data{}(Var'Unds'33:SortData{},Var'Unds'34:SortData{})) + )), + \top{R} () + )) + ))))), + \or{R} ( + \exists{R} (Var'Unds'35:SortData{}, + \exists{R} (Var'Unds'36:SortData{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD1:SortData{}, + inj{SortOptionData{}, SortData{}}(LblSome'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OptionData'Unds'Data{}(Var'Unds'35:SortData{})) + )),\and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD2:SortData{}, + inj{SortOptionData{}, SortData{}}(LblSome'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OptionData'Unds'Data{}(Var'Unds'36:SortData{})) + )), + \top{R} () + )) + ))), + \or{R} ( + \exists{R} (Var'Unds'40:SortSet{}, + \exists{R} (Var'Unds'39:SortData{}, + \exists{R} (Var'Unds'37:SortData{}, + \exists{R} (Var'Unds'38:SortSet{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD1:SortData{}, + inj{SortSet{}, SortData{}}(Lbl'Unds'Set'Unds'{}(LblSetItem{}(inj{SortData{}, SortKItem{}}(Var'Unds'37:SortData{})),Var'Unds'38:SortSet{})) + )),\and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD2:SortData{}, + inj{SortSet{}, SortData{}}(Lbl'Unds'Set'Unds'{}(LblSetItem{}(inj{SortData{}, SortKItem{}}(Var'Unds'39:SortData{})),Var'Unds'40:SortSet{})) + )), + \top{R} () + )) + ))))), + \or{R} ( + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD1:SortData{}, + inj{SortMap{}, SortData{}}(Lbl'Stop'Map{}()) + )),\and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD2:SortData{}, + inj{SortMap{}, SortData{}}(Lbl'Stop'Map{}()) + )), + \top{R} () + )) + ), + \or{R} ( + \exists{R} (Var'Unds'46:SortList{}, + \exists{R} (Var'Unds'44:SortList{}, + \exists{R} (Var'Unds'45:SortData{}, + \exists{R} (Var'Unds'43:SortData{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD1:SortData{}, + inj{SortList{}, SortData{}}(Lbl'Unds'List'Unds'{}(LblListItem{}(inj{SortData{}, SortKItem{}}(Var'Unds'43:SortData{})),Var'Unds'44:SortList{})) + )),\and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarD2:SortData{}, + inj{SortList{}, SortData{}}(Lbl'Unds'List'Unds'{}(LblListItem{}(inj{SortData{}, SortKItem{}}(Var'Unds'45:SortData{})),Var'Unds'46:SortList{})) + )), + \top{R} () + )) + ))))), + \bottom{R}() + )))))))))))))) + ), + \top{R}() + ), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(VarD1:SortData{},VarD2:SortData{}), + Lbl'UndsEqlsEqls'K'Unds'{}(kseq{}(inj{SortData{}, SortKItem{}}(VarD1:SortData{}),dotk{}()),kseq{}(inj{SortData{}, SortKItem{}}(VarD2:SortData{}),dotk{}()))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2381"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2344,8,2344,37)"), owise{}(), UNIQUE'Unds'ID{}("edb00babc7085ec7338499a0c57df6fb841b3e581bb8d771c4f245c6e1012284")] + +// rule `#Matches(_,_)_MATCHER_Bool_Data_Data`(`#Any_UNIT-TEST-COMMON-SYNTAX_Data`(.KList),_0)=>#token("true","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(4061d202865bf768de0eecb1d6a3366989930091f5ab1e55c0e6eb204a3f6111), contentStartColumn(8), contentStartLine(2383), org.kframework.attributes.Location(Location(2346,8,2346,33)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(Lbl'Hash'Any'Unds'UNIT-TEST-COMMON-SYNTAX'Unds'Data{}(),Var'Unds'0:SortData{}), + \dv{SortBool{}}("true")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2383"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2346,8,2346,33)"), UNIQUE'Unds'ID{}("4061d202865bf768de0eecb1d6a3366989930091f5ab1e55c0e6eb204a3f6111")] + +// rule `#Matches(_,_)_MATCHER_Bool_Data_Data`(inj{List,Data}(`.List`(.KList)),inj{List,Data}(`.List`(.KList)))=>#token("true","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(f996604c3b4363ab51835a8a2b9c2a6f1e8a4b3c31f41a9a6c7c5c4aba642644), contentStartColumn(8), contentStartLine(2385), org.kframework.attributes.Location(Location(2348,8,2348,38)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(inj{SortList{}, SortData{}}(Lbl'Stop'List{}()),inj{SortList{}, SortData{}}(Lbl'Stop'List{}())), + \dv{SortBool{}}("true")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2385"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2348,8,2348,38)"), UNIQUE'Unds'ID{}("f996604c3b4363ab51835a8a2b9c2a6f1e8a4b3c31f41a9a6c7c5c4aba642644")] + +// rule `#Matches(_,_)_MATCHER_Bool_Data_Data`(inj{Map,Data}(`.Map`(.KList)),inj{Map,Data}(`.Map`(.KList)))=>#token("true","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(e41a88b22557555f0fed205229591c37bdafcd7f725d7c7672c5f5f71a589d15), contentStartColumn(8), contentStartLine(2393), org.kframework.attributes.Location(Location(2356,8,2356,36)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(inj{SortMap{}, SortData{}}(Lbl'Stop'Map{}()),inj{SortMap{}, SortData{}}(Lbl'Stop'Map{}())), + \dv{SortBool{}}("true")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2393"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2356,8,2356,36)"), UNIQUE'Unds'ID{}("e41a88b22557555f0fed205229591c37bdafcd7f725d7c7672c5f5f71a589d15")] + +// rule `#Matches(_,_)_MATCHER_Bool_Data_Data`(inj{Set,Data}(`.Set`(.KList)),inj{Set,Data}(`.Set`(.KList)))=>#token("true","Bool") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(e82f0f3d51ab7f5176d07f1364353743410444fe4ea72889ccab3ad5c7377e31), contentStartColumn(8), contentStartLine(2389), org.kframework.attributes.Location(Location(2352,8,2352,36)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(inj{SortSet{}, SortData{}}(Lbl'Stop'Set{}()),inj{SortSet{}, SortData{}}(Lbl'Stop'Set{}())), + \dv{SortBool{}}("true")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2389"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2352,8,2352,36)"), UNIQUE'Unds'ID{}("e82f0f3d51ab7f5176d07f1364353743410444fe4ea72889ccab3ad5c7377e31")] + +// rule `#Matches(_,_)_MATCHER_Bool_Data_Data`(inj{BlockchainOperation,Data}(`Create_contract(_,_,_,_,_)_MICHELSON-INTERNAL-SYNTAX_BlockchainOperation_Int_Contract_OptionData_Mutez_Data`(I1,C,O1,M1,D1)),inj{BlockchainOperation,Data}(`Create_contract(_,_,_,_,_)_MICHELSON-INTERNAL-SYNTAX_BlockchainOperation_Int_Contract_OptionData_Mutez_Data`(I2,C,O2,M2,D2)))=>`_andBool_`(`_andBool_`(`_andBool_`(`#Matches(_,_)_MATCHER_Bool_Data_Data`(inj{Int,Data}(I1),inj{Int,Data}(I2)),`#Matches(_,_)_MATCHER_Bool_Data_Data`(inj{OptionData,Data}(O1),inj{OptionData,Data}(O2))),`#Matches(_,_)_MATCHER_Bool_Data_Data`(inj{Mutez,Data}(M1),inj{Mutez,Data}(M2))),`#Matches(_,_)_MATCHER_Bool_Data_Data`(D1,D2)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(2c92bf88f2e62dd0ae032c19939d40dc1bd9974952c349e124a4b1024fef223c), contentStartColumn(8), contentStartLine(2399), org.kframework.attributes.Location(Location(2362,8,2367,23)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(inj{SortBlockchainOperation{}, SortData{}}(LblCreate'Unds'contract'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Contract'Unds'OptionData'Unds'Mutez'Unds'Data{}(VarI1:SortInt{},VarC:SortContract{},VarO1:SortOptionData{},VarM1:SortMutez{},VarD1:SortData{})),inj{SortBlockchainOperation{}, SortData{}}(LblCreate'Unds'contract'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Contract'Unds'OptionData'Unds'Mutez'Unds'Data{}(VarI2:SortInt{},VarC:SortContract{},VarO2:SortOptionData{},VarM2:SortMutez{},VarD2:SortData{}))), + Lbl'Unds'andBool'Unds'{}(Lbl'Unds'andBool'Unds'{}(Lbl'Unds'andBool'Unds'{}(Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(inj{SortInt{}, SortData{}}(VarI1:SortInt{}),inj{SortInt{}, SortData{}}(VarI2:SortInt{})),Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(inj{SortOptionData{}, SortData{}}(VarO1:SortOptionData{}),inj{SortOptionData{}, SortData{}}(VarO2:SortOptionData{}))),Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(inj{SortMutez{}, SortData{}}(VarM1:SortMutez{}),inj{SortMutez{}, SortData{}}(VarM2:SortMutez{}))),Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(VarD1:SortData{},VarD2:SortData{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2399"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2362,8,2367,23)"), UNIQUE'Unds'ID{}("2c92bf88f2e62dd0ae032c19939d40dc1bd9974952c349e124a4b1024fef223c")] + +// rule `#Matches(_,_)_MATCHER_Bool_Data_Data`(inj{OrData,Data}(`Left__MICHELSON-COMMON-SYNTAX_OrData_Data`(D1)),inj{OrData,Data}(`Left__MICHELSON-COMMON-SYNTAX_OrData_Data`(D2)))=>`#Matches(_,_)_MATCHER_Bool_Data_Data`(D1,D2) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(93dbdb2dbfa41c243502c534abd045dc3c41707df4135fe9f5bde4b33c23bb0a), contentStartColumn(8), contentStartLine(2422), org.kframework.attributes.Location(Location(2385,8,2385,54)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(inj{SortOrData{}, SortData{}}(LblLeft'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(VarD1:SortData{})),inj{SortOrData{}, SortData{}}(LblLeft'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(VarD2:SortData{}))), + Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(VarD1:SortData{},VarD2:SortData{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2422"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2385,8,2385,54)"), UNIQUE'Unds'ID{}("93dbdb2dbfa41c243502c534abd045dc3c41707df4135fe9f5bde4b33c23bb0a")] + +// rule `#Matches(_,_)_MATCHER_Bool_Data_Data`(inj{Pair,Data}(`Pair___MICHELSON-COMMON-SYNTAX_Pair_Data_Data`(L1,R1)),inj{Pair,Data}(`Pair___MICHELSON-COMMON-SYNTAX_Pair_Data_Data`(L2,R2)))=>`_andBool_`(`#Matches(_,_)_MATCHER_Bool_Data_Data`(L1,L2),`#Matches(_,_)_MATCHER_Bool_Data_Data`(R1,R2)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(24504057d4f3a4e27f440f93ec8cf67ef22485c5f49bcec7e9a6df151bc721ba), contentStartColumn(8), contentStartLine(2417), org.kframework.attributes.Location(Location(2380,8,2381,49)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(inj{SortPair{}, SortData{}}(LblPair'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Pair'Unds'Data'Unds'Data{}(VarL1:SortData{},VarR1:SortData{})),inj{SortPair{}, SortData{}}(LblPair'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Pair'Unds'Data'Unds'Data{}(VarL2:SortData{},VarR2:SortData{}))), + Lbl'Unds'andBool'Unds'{}(Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(VarL1:SortData{},VarL2:SortData{}),Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(VarR1:SortData{},VarR2:SortData{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2417"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2380,8,2381,49)"), UNIQUE'Unds'ID{}("24504057d4f3a4e27f440f93ec8cf67ef22485c5f49bcec7e9a6df151bc721ba")] + +// rule `#Matches(_,_)_MATCHER_Bool_Data_Data`(inj{OrData,Data}(`Right__MICHELSON-COMMON-SYNTAX_OrData_Data`(D1)),inj{OrData,Data}(`Right__MICHELSON-COMMON-SYNTAX_OrData_Data`(D2)))=>`#Matches(_,_)_MATCHER_Bool_Data_Data`(D1,D2) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(1c488e10867dd1401881031d0263228722f61c459e347b939537ad7f68a3f5ce), contentStartColumn(8), contentStartLine(2423), org.kframework.attributes.Location(Location(2386,8,2386,56)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(inj{SortOrData{}, SortData{}}(LblRight'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(VarD1:SortData{})),inj{SortOrData{}, SortData{}}(LblRight'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(VarD2:SortData{}))), + Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(VarD1:SortData{},VarD2:SortData{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2423"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2386,8,2386,56)"), UNIQUE'Unds'ID{}("1c488e10867dd1401881031d0263228722f61c459e347b939537ad7f68a3f5ce")] + +// rule `#Matches(_,_)_MATCHER_Bool_Data_Data`(inj{BlockchainOperation,Data}(`Set_delegate(_,_)_MICHELSON-INTERNAL-SYNTAX_BlockchainOperation_Int_OptionData`(I1,O1)),inj{BlockchainOperation,Data}(`Set_delegate(_,_)_MICHELSON-INTERNAL-SYNTAX_BlockchainOperation_Int_OptionData`(I2,O2)))=>`_andBool_`(`#Matches(_,_)_MATCHER_Bool_Data_Data`(inj{Int,Data}(I1),inj{Int,Data}(I2)),`#Matches(_,_)_MATCHER_Bool_Data_Data`(inj{OptionData,Data}(O1),inj{OptionData,Data}(O2))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(3d57cd822fe30f2452550e3319b9422eecd3be7cf67de347b508c6df5ebd5363), contentStartColumn(8), contentStartLine(2413), org.kframework.attributes.Location(Location(2376,8,2378,49)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(inj{SortBlockchainOperation{}, SortData{}}(LblSet'Unds'delegate'LParUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'OptionData{}(VarI1:SortInt{},VarO1:SortOptionData{})),inj{SortBlockchainOperation{}, SortData{}}(LblSet'Unds'delegate'LParUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'OptionData{}(VarI2:SortInt{},VarO2:SortOptionData{}))), + Lbl'Unds'andBool'Unds'{}(Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(inj{SortInt{}, SortData{}}(VarI1:SortInt{}),inj{SortInt{}, SortData{}}(VarI2:SortInt{})),Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(inj{SortOptionData{}, SortData{}}(VarO1:SortOptionData{}),inj{SortOptionData{}, SortData{}}(VarO2:SortOptionData{})))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2413"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2376,8,2378,49)"), UNIQUE'Unds'ID{}("3d57cd822fe30f2452550e3319b9422eecd3be7cf67de347b508c6df5ebd5363")] + +// rule `#Matches(_,_)_MATCHER_Bool_Data_Data`(inj{OptionData,Data}(`Some__MICHELSON-COMMON-SYNTAX_OptionData_Data`(D1)),inj{OptionData,Data}(`Some__MICHELSON-COMMON-SYNTAX_OptionData_Data`(D2)))=>`#Matches(_,_)_MATCHER_Bool_Data_Data`(D1,D2) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(59c05f26fd85caa3fa1514b9df513dc190617574b5c788e2296c038cfc887883), contentStartColumn(8), contentStartLine(2420), org.kframework.attributes.Location(Location(2383,8,2383,54)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(inj{SortOptionData{}, SortData{}}(LblSome'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OptionData'Unds'Data{}(VarD1:SortData{})),inj{SortOptionData{}, SortData{}}(LblSome'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OptionData'Unds'Data{}(VarD2:SortData{}))), + Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(VarD1:SortData{},VarD2:SortData{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2420"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2383,8,2383,54)"), UNIQUE'Unds'ID{}("59c05f26fd85caa3fa1514b9df513dc190617574b5c788e2296c038cfc887883")] + +// rule `#Matches(_,_)_MATCHER_Bool_Data_Data`(inj{BlockchainOperation,Data}(`Transfer_tokens(_,_,_,_)_MICHELSON-INTERNAL-SYNTAX_BlockchainOperation_Int_Data_Mutez_Address`(I1,D1,M1,A1)),inj{BlockchainOperation,Data}(`Transfer_tokens(_,_,_,_)_MICHELSON-INTERNAL-SYNTAX_BlockchainOperation_Int_Data_Mutez_Address`(I2,D2,M2,A2)))=>`_andBool_`(`_andBool_`(`_andBool_`(`#Matches(_,_)_MATCHER_Bool_Data_Data`(inj{Int,Data}(I1),inj{Int,Data}(I2)),`#Matches(_,_)_MATCHER_Bool_Data_Data`(D1,D2)),`#Matches(_,_)_MATCHER_Bool_Data_Data`(inj{Mutez,Data}(M1),inj{Mutez,Data}(M2))),`#Matches(_,_)_MATCHER_Bool_Data_Data`(inj{Address,Data}(A1),inj{Address,Data}(A2))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(fb548fe2c1036a5ffe0e1db94925ded571a4d34b8681bfc8e7aa148d192976a6), contentStartColumn(8), contentStartLine(2406), org.kframework.attributes.Location(Location(2369,8,2374,24)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(inj{SortBlockchainOperation{}, SortData{}}(LblTransfer'Unds'tokens'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Data'Unds'Mutez'Unds'Address{}(VarI1:SortInt{},VarD1:SortData{},VarM1:SortMutez{},VarA1:SortAddress{})),inj{SortBlockchainOperation{}, SortData{}}(LblTransfer'Unds'tokens'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Data'Unds'Mutez'Unds'Address{}(VarI2:SortInt{},VarD2:SortData{},VarM2:SortMutez{},VarA2:SortAddress{}))), + Lbl'Unds'andBool'Unds'{}(Lbl'Unds'andBool'Unds'{}(Lbl'Unds'andBool'Unds'{}(Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(inj{SortInt{}, SortData{}}(VarI1:SortInt{}),inj{SortInt{}, SortData{}}(VarI2:SortInt{})),Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(VarD1:SortData{},VarD2:SortData{})),Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(inj{SortMutez{}, SortData{}}(VarM1:SortMutez{}),inj{SortMutez{}, SortData{}}(VarM2:SortMutez{}))),Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(inj{SortAddress{}, SortData{}}(VarA1:SortAddress{}),inj{SortAddress{}, SortData{}}(VarA2:SortAddress{})))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2406"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2369,8,2374,24)"), UNIQUE'Unds'ID{}("fb548fe2c1036a5ffe0e1db94925ded571a4d34b8681bfc8e7aa148d192976a6")] + +// rule `#Matches(_,_)_MATCHER_Bool_Data_Data`(inj{List,Data}(`_List_`(`ListItem`(inj{Data,KItem}(L1)),Ls1)),inj{List,Data}(`_List_`(`ListItem`(inj{Data,KItem}(L2)),Ls2)))=>`_andBool_`(`#Matches(_,_)_MATCHER_Bool_Data_Data`(L1,L2),`#Matches(_,_)_MATCHER_Bool_Data_Data`(inj{List,Data}(Ls1),inj{List,Data}(Ls2))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(3cb3034eaca17926d05392516ca7ade211b869c7c1c82f2e9d5c919ab95c41de), contentStartColumn(8), contentStartLine(2386), org.kframework.attributes.Location(Location(2349,8,2350,51)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(inj{SortList{}, SortData{}}(Lbl'Unds'List'Unds'{}(LblListItem{}(inj{SortData{}, SortKItem{}}(VarL1:SortData{})),VarLs1:SortList{})),inj{SortList{}, SortData{}}(Lbl'Unds'List'Unds'{}(LblListItem{}(inj{SortData{}, SortKItem{}}(VarL2:SortData{})),VarLs2:SortList{}))), + Lbl'Unds'andBool'Unds'{}(Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(VarL1:SortData{},VarL2:SortData{}),Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(inj{SortList{}, SortData{}}(VarLs1:SortList{}),inj{SortList{}, SortData{}}(VarLs2:SortList{})))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2386"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2349,8,2350,51)"), UNIQUE'Unds'ID{}("3cb3034eaca17926d05392516ca7ade211b869c7c1c82f2e9d5c919ab95c41de")] + +// rule `#Matches(_,_)_MATCHER_Bool_Data_Data`(inj{Map,Data}(`_Map_`(`_|->_`(K,inj{Data,KItem}(V1)),M1)),inj{Map,Data}(`_Map_`(`_|->_`(K,inj{Data,KItem}(V2)),M2)))=>`_andBool_`(`#Matches(_,_)_MATCHER_Bool_Data_Data`(V1,V2),`#Matches(_,_)_MATCHER_Bool_Data_Data`(inj{Map,Data}(M1),inj{Map,Data}(M2))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(c4658bb1cd666fad2d6df62948a1caac32ba8309253c33b9bf1f7cb121dfeba0), contentStartColumn(8), contentStartLine(2394), org.kframework.attributes.Location(Location(2357,8,2358,49)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(inj{SortMap{}, SortData{}}(Lbl'Unds'Map'Unds'{}(Lbl'UndsPipe'-'-GT-Unds'{}(VarK:SortKItem{},inj{SortData{}, SortKItem{}}(VarV1:SortData{})),VarM1:SortMap{})),inj{SortMap{}, SortData{}}(Lbl'Unds'Map'Unds'{}(Lbl'UndsPipe'-'-GT-Unds'{}(VarK:SortKItem{},inj{SortData{}, SortKItem{}}(VarV2:SortData{})),VarM2:SortMap{}))), + Lbl'Unds'andBool'Unds'{}(Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(VarV1:SortData{},VarV2:SortData{}),Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(inj{SortMap{}, SortData{}}(VarM1:SortMap{}),inj{SortMap{}, SortData{}}(VarM2:SortMap{})))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2394"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2357,8,2358,49)"), UNIQUE'Unds'ID{}("c4658bb1cd666fad2d6df62948a1caac32ba8309253c33b9bf1f7cb121dfeba0")] + +// rule `#Matches(_,_)_MATCHER_Bool_Data_Data`(inj{Set,Data}(`_Set_`(`SetItem`(inj{Data,KItem}(S1)),Ss1)),inj{Set,Data}(`_Set_`(`SetItem`(inj{Data,KItem}(S2)),Ss2)))=>`_andBool_`(`#Matches(_,_)_MATCHER_Bool_Data_Data`(S1,S2),`#Matches(_,_)_MATCHER_Bool_Data_Data`(inj{Set,Data}(Ss1),inj{Set,Data}(Ss2))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(420d300682a1e551a87dc75c967742f4aa9c7db9ad063243e544ccb7ea277268), contentStartColumn(8), contentStartLine(2390), org.kframework.attributes.Location(Location(2353,8,2354,51)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(inj{SortSet{}, SortData{}}(Lbl'Unds'Set'Unds'{}(LblSetItem{}(inj{SortData{}, SortKItem{}}(VarS1:SortData{})),VarSs1:SortSet{})),inj{SortSet{}, SortData{}}(Lbl'Unds'Set'Unds'{}(LblSetItem{}(inj{SortData{}, SortKItem{}}(VarS2:SortData{})),VarSs2:SortSet{}))), + Lbl'Unds'andBool'Unds'{}(Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(VarS1:SortData{},VarS2:SortData{}),Lbl'Hash'Matches'LParUndsCommUndsRParUnds'MATCHER'Unds'Bool'Unds'Data'Unds'Data{}(inj{SortSet{}, SortData{}}(VarSs1:SortSet{}),inj{SortSet{}, SortData{}}(VarSs2:SortSet{})))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2390"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2353,8,2354,51)"), UNIQUE'Unds'ID{}("420d300682a1e551a87dc75c967742f4aa9c7db9ad063243e544ccb7ea277268")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{MapLiteral,DataOrSeq}(`{_}_MICHELSON-COMMON-SYNTAX_MapLiteral_MapEntryList`(M)) #as _1,`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(inj{MapTypeName,BinaryTypeName}(`big_map_MICHELSON-COMMON-SYNTAX_MapTypeName`(.KList)),_0,K,V),KnownAddrs,BigMaps,#Configuration)=>`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(_1,`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(inj{MapTypeName,BinaryTypeName}(`map_MICHELSON-COMMON-SYNTAX_MapTypeName`(.KList)),`.List{"___MICHELSON-COMMON-SYNTAX_AnnotationList_Annotation_AnnotationList"}_AnnotationList`(.KList),K,V),KnownAddrs,BigMaps,#Configuration) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(ec251a2ec10ea0f946f7ec95d38c94180fe22b823ae82e4da27554b5437d20ae), contentStartColumn(8), contentStartLine(379), org.kframework.attributes.Location(Location(379,8,380,92)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(\and{SortDataOrSeq{}}(inj{SortMapLiteral{}, SortDataOrSeq{}}(Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'MapLiteral'Unds'MapEntryList{}(VarM:SortMapEntryList{})),Var'Unds'1:SortDataOrSeq{}),Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(inj{SortMapTypeName{}, SortBinaryTypeName{}}(Lblbig'Unds'map'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}()),Var'Unds'0:SortAnnotationList{},VarK:SortType{},VarV:SortType{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(Var'Unds'1:SortDataOrSeq{},Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(inj{SortMapTypeName{}, SortBinaryTypeName{}}(Lblmap'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}()),Lbl'Stop'List'LBraQuotUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList'QuotRBraUnds'AnnotationList{}(),VarK:SortType{},VarV:SortType{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("379"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(379,8,380,92)"), UNIQUE'Unds'ID{}("ec251a2ec10ea0f946f7ec95d38c94180fe22b823ae82e4da27554b5437d20ae")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Data,DataOrSeq}(`#Any_UNIT-TEST-COMMON-SYNTAX_Data`(.KList) #as _4),_0,_1,_2,#Configuration)=>_4 requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(26699d53bc53c2d84fb1c89f6cad0abf0b5bffd93e9871698772dddcd380068d), contentStartColumn(8), contentStartLine(449), org.kframework.attributes.Location(Location(449,8,449,49)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortData{}, SortDataOrSeq{}}(\and{SortData{}}(Lbl'Hash'Any'Unds'UNIT-TEST-COMMON-SYNTAX'Unds'Data{}(),Var'Unds'4:SortData{})),Var'Unds'0:SortType{},Var'Unds'1:SortMap{},Var'Unds'2:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + Var'Unds'4:SortData{}), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("449"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(449,8,449,49)"), UNIQUE'Unds'ID{}("26699d53bc53c2d84fb1c89f6cad0abf0b5bffd93e9871698772dddcd380068d")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{OptionData,DataOrSeq}(`None_MICHELSON-COMMON-SYNTAX_OptionData`(.KList) #as _3),`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(`option_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList),_0,_1),_KnownAddrs,_BigMaps,#Configuration)=>inj{OptionData,Data}(_3) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(f7a3615bbc98bc5da6c3450093eeb3401f80a3db722085fb8160753a071f3528), contentStartColumn(8), contentStartLine(319), org.kframework.attributes.Location(Location(319,8,319,90)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortOptionData{}, SortDataOrSeq{}}(\and{SortOptionData{}}(LblNone'Unds'MICHELSON-COMMON-SYNTAX'Unds'OptionData{}(),Var'Unds'3:SortOptionData{})),Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Lbloption'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'0:SortAnnotationList{},Var'Unds'1:SortType{}),Var'Unds'KnownAddrs:SortMap{},Var'Unds'BigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortOptionData{}, SortData{}}(Var'Unds'3:SortOptionData{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("319"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(319,8,319,90)"), UNIQUE'Unds'ID{}("f7a3615bbc98bc5da6c3450093eeb3401f80a3db722085fb8160753a071f3528")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{SimpleData,DataOrSeq}(`Unit_MICHELSON-COMMON-SYNTAX_SimpleData`(.KList) #as _2),`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(`unit_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList),_0),_KnownAddrs,_BigMaps,#Configuration)=>inj{SimpleData,Data}(_2) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(3d97697e8faed82ad3fc1f1717fc6b6d8a4987041dd40037d8f4a6cfde922f4d), contentStartColumn(8), contentStartLine(307), org.kframework.attributes.Location(Location(307,8,307,71)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortSimpleData{}, SortDataOrSeq{}}(\and{SortSimpleData{}}(LblUnit'Unds'MICHELSON-COMMON-SYNTAX'Unds'SimpleData{}(),Var'Unds'2:SortSimpleData{})),Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(Lblunit'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(),Var'Unds'0:SortAnnotationList{}),Var'Unds'KnownAddrs:SortMap{},Var'Unds'BigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortSimpleData{}, SortData{}}(Var'Unds'2:SortSimpleData{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("307"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(307,8,307,71)"), UNIQUE'Unds'ID{}("3d97697e8faed82ad3fc1f1717fc6b6d8a4987041dd40037d8f4a6cfde922f4d")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Bool,DataOrSeq}(B),`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(`bool_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList),_0),_KnownAddrs,_BigMaps,#Configuration)=>inj{Bool,Data}(B) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(0dfcf3f936b2d8ef9617015bccd5043962173108b5852da23df522c9334c8d8b), contentStartColumn(8), contentStartLine(301), org.kframework.attributes.Location(Location(301,8,301,70)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortBool{}, SortDataOrSeq{}}(VarB:SortBool{}),Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(Lblbool'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(),Var'Unds'0:SortAnnotationList{}),Var'Unds'KnownAddrs:SortMap{},Var'Unds'BigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortBool{}, SortData{}}(VarB:SortBool{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("301"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(301,8,301,70)"), UNIQUE'Unds'ID{}("0dfcf3f936b2d8ef9617015bccd5043962173108b5852da23df522c9334c8d8b")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{MBytes,DataOrSeq}(B),`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(`bytes_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList),_0),_KnownAddrs,_BigMaps,#Configuration)=>inj{MBytes,Data}(B) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(52b2b5b32621e9b5a7c939034dba480e2e4164a2ff3a73d257fd89c7da0b1a07), contentStartColumn(8), contentStartLine(286), org.kframework.attributes.Location(Location(286,8,286,73)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortMBytes{}, SortDataOrSeq{}}(VarB:SortMBytes{}),Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(Lblbytes'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(),Var'Unds'0:SortAnnotationList{}),Var'Unds'KnownAddrs:SortMap{},Var'Unds'BigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortMBytes{}, SortData{}}(VarB:SortMBytes{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("286"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(286,8,286,73)"), UNIQUE'Unds'ID{}("52b2b5b32621e9b5a7c939034dba480e2e4164a2ff3a73d257fd89c7da0b1a07")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Block,DataOrSeq}(B),`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(`lambda_MICHELSON-COMMON-SYNTAX_BinaryTypeName`(.KList),_0,T1,T2),_KnownAddrs,_BigMaps,#Configuration)=>inj{LambdaData,Data}(`#Lambda(_,_,_)_MICHELSON-COMMON_LambdaData_TypeName_TypeName_Block`(`#Name(_)_MICHELSON-COMMON_TypeName_Type`(T1),`#Name(_)_MICHELSON-COMMON_TypeName_Type`(T2),B)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(6f259034961ae552794359d4d9a9afddd9a860e7bab13ffe89768b7ac78a8801), contentStartColumn(8), contentStartLine(328), org.kframework.attributes.Location(Location(328,8,328,125)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortBlock{}, SortDataOrSeq{}}(VarB:SortBlock{}),Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(Lbllambda'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}(),Var'Unds'0:SortAnnotationList{},VarT1:SortType{},VarT2:SortType{}),Var'Unds'KnownAddrs:SortMap{},Var'Unds'BigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortLambdaData{}, SortData{}}(Lbl'Hash'Lambda'LParUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'LambdaData'Unds'TypeName'Unds'TypeName'Unds'Block{}(Lbl'Hash'Name'LParUndsRParUnds'MICHELSON-COMMON'Unds'TypeName'Unds'Type{}(VarT1:SortType{}),Lbl'Hash'Name'LParUndsRParUnds'MICHELSON-COMMON'Unds'TypeName'Unds'Type{}(VarT2:SortType{}),VarB:SortBlock{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("328"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(328,8,328,125)"), UNIQUE'Unds'ID{}("6f259034961ae552794359d4d9a9afddd9a860e7bab13ffe89768b7ac78a8801")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{MBytes,DataOrSeq}(H),`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(`chain_id_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList),_0),_KnownAddrs,_BigMaps,#Configuration)=>inj{ChainId,Data}(`#ChainId(_)_MICHELSON-COMMON_ChainId_MBytes`(H)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(2a5627e572cdda38682a18ad0fdf4edd3d8276138a1091114e910c7704b53af2), contentStartColumn(8), contentStartLine(266), org.kframework.attributes.Location(Location(266,8,266,86)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortMBytes{}, SortDataOrSeq{}}(VarH:SortMBytes{}),Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(Lblchain'Unds'id'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(),Var'Unds'0:SortAnnotationList{}),Var'Unds'KnownAddrs:SortMap{},Var'Unds'BigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortChainId{}, SortData{}}(Lbl'Hash'ChainId'LParUndsRParUnds'MICHELSON-COMMON'Unds'ChainId'Unds'MBytes{}(VarH:SortMBytes{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("266"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(266,8,266,86)"), UNIQUE'Unds'ID{}("2a5627e572cdda38682a18ad0fdf4edd3d8276138a1091114e910c7704b53af2")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Int,DataOrSeq}(I),`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(inj{NumTypeName,NullaryTypeName}(`int_MICHELSON-COMMON-SYNTAX_NumTypeName`(.KList)),_0),_KnownAddrs,_BigMaps,#Configuration)=>inj{Int,Data}(I) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(c4494a39299dcd95d554636b4f7020fe245255dc588dbf5ca8fe29557cd6d748), contentStartColumn(8), contentStartLine(273), org.kframework.attributes.Location(Location(273,8,273,68)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortInt{}, SortDataOrSeq{}}(VarI:SortInt{}),Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(inj{SortNumTypeName{}, SortNullaryTypeName{}}(Lblint'Unds'MICHELSON-COMMON-SYNTAX'Unds'NumTypeName{}()),Var'Unds'0:SortAnnotationList{}),Var'Unds'KnownAddrs:SortMap{},Var'Unds'BigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortInt{}, SortData{}}(VarI:SortInt{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("273"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(273,8,273,68)"), UNIQUE'Unds'ID{}("c4494a39299dcd95d554636b4f7020fe245255dc588dbf5ca8fe29557cd6d748")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Int,DataOrSeq}(I),`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(inj{NumTypeName,NullaryTypeName}(`nat_MICHELSON-COMMON-SYNTAX_NumTypeName`(.KList)),_0),_KnownAddrs,_BigMaps,#Configuration)=>inj{Int,Data}(I) requires `_>=Int_`(I,#token("0","Int")) ensures #token("true","Bool") [UNIQUE_ID(3e8187949f1c0ad9127e5ac382c141575c61e5ca2366b4ab37c876050fe755e9), contentStartColumn(8), contentStartLine(274), org.kframework.attributes.Location(Location(274,8,274,87)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol])] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + Lbl'Unds-GT-Eqls'Int'Unds'{}(VarI:SortInt{},\dv{SortInt{}}("0")), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortInt{}, SortDataOrSeq{}}(VarI:SortInt{}),Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(inj{SortNumTypeName{}, SortNullaryTypeName{}}(Lblnat'Unds'MICHELSON-COMMON-SYNTAX'Unds'NumTypeName{}()),Var'Unds'0:SortAnnotationList{}),Var'Unds'KnownAddrs:SortMap{},Var'Unds'BigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortInt{}, SortData{}}(VarI:SortInt{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("274"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(274,8,274,87)"), UNIQUE'Unds'ID{}("3e8187949f1c0ad9127e5ac382c141575c61e5ca2366b4ab37c876050fe755e9")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Int,DataOrSeq}(I),`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(`mutez_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList),_0),_KnownAddrs,_BigMaps,#Configuration)=>inj{Mutez,Data}(`#Mutez(_)_MICHELSON-COMMON_Mutez_Int`(I)) requires `#IsLegalMutezValue(_)_MICHELSON-COMMON_Bool_Int`(I) ensures #token("true","Bool") [UNIQUE_ID(a69e5cce6dfa952e44b82688ed725b58a068770029e135b08dcb8fd500a185dd), contentStartColumn(8), contentStartLine(293), org.kframework.attributes.Location(Location(293,8,293,109)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol])] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + Lbl'Hash'IsLegalMutezValue'LParUndsRParUnds'MICHELSON-COMMON'Unds'Bool'Unds'Int{}(VarI:SortInt{}), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortInt{}, SortDataOrSeq{}}(VarI:SortInt{}),Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(Lblmutez'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(),Var'Unds'0:SortAnnotationList{}),Var'Unds'KnownAddrs:SortMap{},Var'Unds'BigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortMutez{}, SortData{}}(Lbl'Hash'Mutez'LParUndsRParUnds'MICHELSON-COMMON'Unds'Mutez'Unds'Int{}(VarI:SortInt{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("293"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(293,8,293,109)"), UNIQUE'Unds'ID{}("a69e5cce6dfa952e44b82688ed725b58a068770029e135b08dcb8fd500a185dd")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Int,DataOrSeq}(I),`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(`timestamp_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList),_0),_KnownAddrs,_BigMaps,#Configuration)=>inj{Timestamp,Data}(`#Timestamp(_)_MICHELSON-COMMON_Timestamp_Int`(I)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(29a1476cb8d613f2bea10f2ba04021bc2a98c5cd4fa3aac148b4535eccf774f7), contentStartColumn(8), contentStartLine(258), org.kframework.attributes.Location(Location(258,8,258,86)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortInt{}, SortDataOrSeq{}}(VarI:SortInt{}),Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(Lbltimestamp'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(),Var'Unds'0:SortAnnotationList{}),Var'Unds'KnownAddrs:SortMap{},Var'Unds'BigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortTimestamp{}, SortData{}}(Lbl'Hash'Timestamp'LParUndsRParUnds'MICHELSON-COMMON'Unds'Timestamp'Unds'Int{}(VarI:SortInt{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("258"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(258,8,258,86)"), UNIQUE'Unds'ID{}("29a1476cb8d613f2bea10f2ba04021bc2a98c5cd4fa3aac148b4535eccf774f7")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Int,DataOrSeq}(I),`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(inj{MapTypeName,BinaryTypeName}(`big_map_MICHELSON-COMMON-SYNTAX_MapTypeName`(.KList)),_0,_K,_V),_KnownAddrs,BigMaps,#Configuration)=>`project:Data`(`Map:lookup`(BigMaps,inj{Int,KItem}(I))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(1f586db7331111b836adf01adb11d1ce4df74af5001e6ad29f895abfc1e3309d), contentStartColumn(8), contentStartLine(443), org.kframework.attributes.Location(Location(443,8,443,109)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortInt{}, SortDataOrSeq{}}(VarI:SortInt{}),Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(inj{SortMapTypeName{}, SortBinaryTypeName{}}(Lblbig'Unds'map'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}()),Var'Unds'0:SortAnnotationList{},Var'Unds'K:SortType{},Var'Unds'V:SortType{}),Var'Unds'KnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + Lblproject'Coln'Data{}(kseq{}(LblMap'Coln'lookup{}(VarBigMaps:SortMap{},inj{SortInt{}, SortKItem{}}(VarI:SortInt{})),dotk{}()))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("443"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(443,8,443,109)"), UNIQUE'Unds'ID{}("1f586db7331111b836adf01adb11d1ce4df74af5001e6ad29f895abfc1e3309d")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{SymbolicData,DataOrSeq}(S),T,_0,_1,``(``(_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,``(Syms),_25,_26,_27),_DotVar0) #as #Configuration)=>inj{SymbolicData,Data}(S) requires `notBool_`(`_in_keys(_)_MAP_Bool_KItem_Map`(inj{SymbolicData,KItem}(S),Syms)) ensures #token("true","Bool") [UNIQUE_ID(5bca172c9da9ef8754c1f9cc2f7c450b5275a7c98fcac32a07458244d2271a85), contentStartColumn(8), contentStartLine(2133), org.kframework.attributes.Location(Location(2127,8,2129,39)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol])] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + LblnotBool'Unds'{}(Lbl'Unds'in'Unds'keys'LParUndsRParUnds'MAP'Unds'Bool'Unds'KItem'Unds'Map{}(inj{SortSymbolicData{}, SortKItem{}}(VarS:SortSymbolicData{}),VarSyms:SortMap{})), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortSymbolicData{}, SortDataOrSeq{}}(VarS:SortSymbolicData{}),VarT:SortType{},Var'Unds'0:SortMap{},Var'Unds'1:SortMap{},\and{SortGeneratedTopCell{}}(Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'2:SortParamtypeCell{},Var'Unds'3:SortParamvalueCell{},Var'Unds'4:SortStoragetypeCell{},Var'Unds'5:SortStoragevalueCell{},Var'Unds'6:SortMybalanceCell{},Var'Unds'7:SortMyamountCell{},Var'Unds'8:SortMynowCell{},Var'Unds'9:SortMyaddrCell{},Var'Unds'10:SortKnownaddrsCell{},Var'Unds'11:SortSourceaddrCell{},Var'Unds'12:SortSenderaddrCell{},Var'Unds'13:SortMychainidCell{},Var'Unds'14:SortNonceCell{},Var'Unds'15:SortBigmapsCell{},Var'Unds'16:SortScriptCell{},Var'Unds'17:SortKCell{},Var'Unds'18:SortStackCell{},Var'Unds'19:SortInputstackCell{},Var'Unds'20:SortExpectedCell{},Var'Unds'21:SortPreCell{},Var'Unds'22:SortPostCell{},Var'Unds'23:SortInvsCell{},Var'Unds'24:SortCutpointsCell{},Lbl'-LT-'symbols'-GT-'{}(VarSyms:SortMap{}),Var'Unds'25:SortReturncodeCell{},Var'Unds'26:SortAssumeFailedCell{},Var'Unds'27:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{}),Var'Hash'Configuration:SortGeneratedTopCell{})), + inj{SortSymbolicData{}, SortData{}}(VarS:SortSymbolicData{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("2133"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2127,8,2129,39)"), UNIQUE'Unds'ID{}("5bca172c9da9ef8754c1f9cc2f7c450b5275a7c98fcac32a07458244d2271a85")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{SymbolicData,DataOrSeq}(S),T,_0,_1,``(``(_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,``(`_Map_`(`_|->_`(inj{SymbolicData,KItem}(S),inj{TypedSymbol,KItem}(`#TypedSymbol(_,_)_MICHELSON_TypedSymbol_TypeName_Data`(TN,D))),_DotVar2)),_25,_26,_27),_DotVar0) #as #Configuration)=>D requires `_==K_`(inj{TypeName,KItem}(TN),inj{TypeName,KItem}(`#Name(_)_MICHELSON-COMMON_TypeName_Type`(T))) ensures #token("true","Bool") [UNIQUE_ID(b46d83d79027d17d2025c6a4a994ad8e22eeb174da6c30acf921d1698f26df23), contentStartColumn(8), contentStartLine(2129), org.kframework.attributes.Location(Location(2123,8,2125,29)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol])] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + Lbl'UndsEqlsEqls'K'Unds'{}(kseq{}(inj{SortTypeName{}, SortKItem{}}(VarTN:SortTypeName{}),dotk{}()),kseq{}(inj{SortTypeName{}, SortKItem{}}(Lbl'Hash'Name'LParUndsRParUnds'MICHELSON-COMMON'Unds'TypeName'Unds'Type{}(VarT:SortType{})),dotk{}())), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortSymbolicData{}, SortDataOrSeq{}}(VarS:SortSymbolicData{}),VarT:SortType{},Var'Unds'0:SortMap{},Var'Unds'1:SortMap{},\and{SortGeneratedTopCell{}}(Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'2:SortParamtypeCell{},Var'Unds'3:SortParamvalueCell{},Var'Unds'4:SortStoragetypeCell{},Var'Unds'5:SortStoragevalueCell{},Var'Unds'6:SortMybalanceCell{},Var'Unds'7:SortMyamountCell{},Var'Unds'8:SortMynowCell{},Var'Unds'9:SortMyaddrCell{},Var'Unds'10:SortKnownaddrsCell{},Var'Unds'11:SortSourceaddrCell{},Var'Unds'12:SortSenderaddrCell{},Var'Unds'13:SortMychainidCell{},Var'Unds'14:SortNonceCell{},Var'Unds'15:SortBigmapsCell{},Var'Unds'16:SortScriptCell{},Var'Unds'17:SortKCell{},Var'Unds'18:SortStackCell{},Var'Unds'19:SortInputstackCell{},Var'Unds'20:SortExpectedCell{},Var'Unds'21:SortPreCell{},Var'Unds'22:SortPostCell{},Var'Unds'23:SortInvsCell{},Var'Unds'24:SortCutpointsCell{},Lbl'-LT-'symbols'-GT-'{}(Lbl'Unds'Map'Unds'{}(Lbl'UndsPipe'-'-GT-Unds'{}(inj{SortSymbolicData{}, SortKItem{}}(VarS:SortSymbolicData{}),inj{SortTypedSymbol{}, SortKItem{}}(Lbl'Hash'TypedSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'TypedSymbol'Unds'TypeName'Unds'Data{}(VarTN:SortTypeName{},VarD:SortData{}))),Var'Unds'DotVar2:SortMap{})),Var'Unds'25:SortReturncodeCell{},Var'Unds'26:SortAssumeFailedCell{},Var'Unds'27:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{}),Var'Hash'Configuration:SortGeneratedTopCell{})), + VarD:SortData{}), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("2129"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2123,8,2125,29)"), UNIQUE'Unds'ID{}("b46d83d79027d17d2025c6a4a994ad8e22eeb174da6c30acf921d1698f26df23")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{String,DataOrSeq}(S),`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(`address_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList),_0),_KnownAddrs,_BigMaps,#Configuration)=>inj{Address,Data}(`#ParseAddress(_)_MICHELSON-COMMON_Address_String`(S)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(fa14e8e2d44963961cbce454b1ac8c91b09cfeb2ce3549510f013a752d267086), contentStartColumn(8), contentStartLine(218), org.kframework.attributes.Location(Location(218,8,218,92)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortString{}, SortDataOrSeq{}}(VarS:SortString{}),Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(Lbladdress'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(),Var'Unds'0:SortAnnotationList{}),Var'Unds'KnownAddrs:SortMap{},Var'Unds'BigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortAddress{}, SortData{}}(Lbl'Hash'ParseAddress'LParUndsRParUnds'MICHELSON-COMMON'Unds'Address'Unds'String{}(VarS:SortString{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("218"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(218,8,218,92)"), UNIQUE'Unds'ID{}("fa14e8e2d44963961cbce454b1ac8c91b09cfeb2ce3549510f013a752d267086")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{String,DataOrSeq}(S),`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(`key_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList),_0),_KnownAddrs,_BigMaps,#Configuration)=>inj{Key,Data}(`#ParseKey(_)_MICHELSON-COMMON_Key_String`(S)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(f6060600089e090bb7b8f1c1cd4a47b455a0c0d37c36bfa5789176665c2f66fd), contentStartColumn(8), contentStartLine(219), org.kframework.attributes.Location(Location(219,8,219,88)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortString{}, SortDataOrSeq{}}(VarS:SortString{}),Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(Lblkey'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(),Var'Unds'0:SortAnnotationList{}),Var'Unds'KnownAddrs:SortMap{},Var'Unds'BigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortKey{}, SortData{}}(Lbl'Hash'ParseKey'LParUndsRParUnds'MICHELSON-COMMON'Unds'Key'Unds'String{}(VarS:SortString{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("219"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(219,8,219,88)"), UNIQUE'Unds'ID{}("f6060600089e090bb7b8f1c1cd4a47b455a0c0d37c36bfa5789176665c2f66fd")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{String,DataOrSeq}(S),`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(`key_hash_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList),_0),_KnownAddrs,_BigMaps,#Configuration)=>inj{KeyHash,Data}(`#ParseKeyHash(_)_MICHELSON-COMMON_KeyHash_String`(S)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(093496e3c3d51f3ac1b5a6680cfc674cba327a5d3800b2c1febceeeacd325faa), contentStartColumn(8), contentStartLine(217), org.kframework.attributes.Location(Location(217,8,217,92)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortString{}, SortDataOrSeq{}}(VarS:SortString{}),Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(Lblkey'Unds'hash'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(),Var'Unds'0:SortAnnotationList{}),Var'Unds'KnownAddrs:SortMap{},Var'Unds'BigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortKeyHash{}, SortData{}}(Lbl'Hash'ParseKeyHash'LParUndsRParUnds'MICHELSON-COMMON'Unds'KeyHash'Unds'String{}(VarS:SortString{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("217"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(217,8,217,92)"), UNIQUE'Unds'ID{}("093496e3c3d51f3ac1b5a6680cfc674cba327a5d3800b2c1febceeeacd325faa")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{String,DataOrSeq}(S),`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(`signature_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList),_0),_KnownAddrs,_BigMaps,#Configuration)=>inj{Signature,Data}(`#ParseSignature(_)_MICHELSON-COMMON_Signature_String`(S)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(c932882be0e91e7e08a46e18b7315c2d11acb5f23caef7b8cb38067e64b32a55), contentStartColumn(8), contentStartLine(220), org.kframework.attributes.Location(Location(220,8,220,94)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortString{}, SortDataOrSeq{}}(VarS:SortString{}),Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(Lblsignature'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(),Var'Unds'0:SortAnnotationList{}),Var'Unds'KnownAddrs:SortMap{},Var'Unds'BigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortSignature{}, SortData{}}(Lbl'Hash'ParseSignature'LParUndsRParUnds'MICHELSON-COMMON'Unds'Signature'Unds'String{}(VarS:SortString{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("220"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(220,8,220,94)"), UNIQUE'Unds'ID{}("c932882be0e91e7e08a46e18b7315c2d11acb5f23caef7b8cb38067e64b32a55")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{String,DataOrSeq}(S),`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(`string_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList),_0),_KnownAddrs,_BigMaps,#Configuration)=>inj{String,Data}(S) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(963e8fab68e13e62fc52e94c9df14ee8cc3014fa8f3406e5201c1b683782fa0a), contentStartColumn(8), contentStartLine(280), org.kframework.attributes.Location(Location(280,8,280,74)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortString{}, SortDataOrSeq{}}(VarS:SortString{}),Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(Lblstring'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(),Var'Unds'0:SortAnnotationList{}),Var'Unds'KnownAddrs:SortMap{},Var'Unds'BigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortString{}, SortData{}}(VarS:SortString{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("280"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(280,8,280,74)"), UNIQUE'Unds'ID{}("963e8fab68e13e62fc52e94c9df14ee8cc3014fa8f3406e5201c1b683782fa0a")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{String,DataOrSeq}(S),`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(`timestamp_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList),_0),_KnownAddrs,_BigMaps,#Configuration)=>inj{Timestamp,Data}(`#ParseTimestamp(_)_MICHELSON-COMMON_Timestamp_String`(S)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(c73b85c2b5a5f7a4dcb841dbfbcb8205548757e0c5c424a767eb2c7105618079), contentStartColumn(8), contentStartLine(221), org.kframework.attributes.Location(Location(221,8,221,94)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortString{}, SortDataOrSeq{}}(VarS:SortString{}),Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(Lbltimestamp'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(),Var'Unds'0:SortAnnotationList{}),Var'Unds'KnownAddrs:SortMap{},Var'Unds'BigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortTimestamp{}, SortData{}}(Lbl'Hash'ParseTimestamp'LParUndsRParUnds'MICHELSON-COMMON'Unds'Timestamp'Unds'String{}(VarS:SortString{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("221"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(221,8,221,94)"), UNIQUE'Unds'ID{}("c73b85c2b5a5f7a4dcb841dbfbcb8205548757e0c5c424a767eb2c7105618079")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{String,DataOrSeq}(S),`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(`contract_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList),_0,T),_KnownAddrs,_BigMaps,#Configuration)=>inj{ContractData,Data}(`#Contract(_,_)_MICHELSON-COMMON_ContractData_Address_Type`(`#ParseAddress(_)_MICHELSON-COMMON_Address_String`(S),T)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(281f8e17e6f82c837bc2675b4b7881e9dee0e972ff8b140c7739570643b79a6a), contentStartColumn(8), contentStartLine(388), org.kframework.attributes.Location(Location(388,8,388,107)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortString{}, SortDataOrSeq{}}(VarS:SortString{}),Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Lblcontract'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'0:SortAnnotationList{},VarT:SortType{}),Var'Unds'KnownAddrs:SortMap{},Var'Unds'BigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortContractData{}, SortData{}}(Lbl'Hash'Contract'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'ContractData'Unds'Address'Unds'Type{}(Lbl'Hash'ParseAddress'LParUndsRParUnds'MICHELSON-COMMON'Unds'Address'Unds'String{}(VarS:SortString{}),VarT:SortType{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("388"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(388,8,388,107)"), UNIQUE'Unds'ID{}("281f8e17e6f82c837bc2675b4b7881e9dee0e972ff8b140c7739570643b79a6a")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{TypedData,DataOrSeq}(`#Typed(_,_)_MICHELSON-COMMON_TypedData_Data_Type`(D,T)),T,KnownAddrs,BigMaps,#Configuration)=>`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Data,DataOrSeq}(D),T,KnownAddrs,BigMaps,#Configuration) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(a9cfc804c79b0fd25c4d2f74d811ab88c1d77d58990649483d02bcd081337e45), contentStartColumn(8), contentStartLine(390), org.kframework.attributes.Location(Location(390,8,390,113)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortTypedData{}, SortDataOrSeq{}}(Lbl'Hash'Typed'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'TypedData'Unds'Data'Unds'Type{}(VarD:SortData{},VarT:SortType{})),VarT:SortType{},VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortData{}, SortDataOrSeq{}}(VarD:SortData{}),VarT:SortType{},VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("390"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(390,8,390,113)"), UNIQUE'Unds'ID{}("a9cfc804c79b0fd25c4d2f74d811ab88c1d77d58990649483d02bcd081337e45")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{BlockchainOperation,DataOrSeq}(`Create_contract(_,_,_,_,_)_MICHELSON-INTERNAL-SYNTAX_BlockchainOperation_Int_Contract_OptionData_Mutez_Data`(N,C,O,M,S)),`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(`operation_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList),_0),KnownAddrs,BigMaps,#Configuration)=>inj{BlockchainOperation,Data}(`Create_contract(_,_,_,_,_)_MICHELSON-INTERNAL-SYNTAX_BlockchainOperation_Int_Contract_OptionData_Mutez_Data`(N,C,`project:OptionData`(inj{Data,KItem}(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{OptionData,DataOrSeq}(O),`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(`option_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList),`.List{"___MICHELSON-COMMON-SYNTAX_AnnotationList_Annotation_AnnotationList"}_AnnotationList`(.KList),`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(`key_hash_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList),`.List{"___MICHELSON-COMMON-SYNTAX_AnnotationList_Annotation_AnnotationList"}_AnnotationList`(.KList))),KnownAddrs,BigMaps,#Configuration))),`project:Mutez`(inj{Data,KItem}(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Mutez,DataOrSeq}(M),`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(`mutez_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList),`.List{"___MICHELSON-COMMON-SYNTAX_AnnotationList_Annotation_AnnotationList"}_AnnotationList`(.KList)),KnownAddrs,BigMaps,#Configuration))),`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Data,DataOrSeq}(S),`#StorageTypeFromContract(_)_MICHELSON-COMMON_Type_Contract`(C),KnownAddrs,BigMaps,#Configuration))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(3bce2caf5602c655c53fdc0b83b4502a8ae40c5233c8db86b354bdfabb00b87c), contentStartColumn(8), contentStartLine(398), org.kframework.attributes.Location(Location(398,8,405,9)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortBlockchainOperation{}, SortDataOrSeq{}}(LblCreate'Unds'contract'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Contract'Unds'OptionData'Unds'Mutez'Unds'Data{}(VarN:SortInt{},VarC:SortContract{},VarO:SortOptionData{},VarM:SortMutez{},VarS:SortData{})),Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(Lbloperation'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(),Var'Unds'0:SortAnnotationList{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortBlockchainOperation{}, SortData{}}(LblCreate'Unds'contract'LParUndsCommUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Contract'Unds'OptionData'Unds'Mutez'Unds'Data{}(VarN:SortInt{},VarC:SortContract{},Lblproject'Coln'OptionData{}(kseq{}(inj{SortData{}, SortKItem{}}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortOptionData{}, SortDataOrSeq{}}(VarO:SortOptionData{}),Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Lbloption'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Lbl'Stop'List'LBraQuotUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList'QuotRBraUnds'AnnotationList{}(),Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(Lblkey'Unds'hash'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(),Lbl'Stop'List'LBraQuotUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList'QuotRBraUnds'AnnotationList{}())),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{})),dotk{}())),Lblproject'Coln'Mutez{}(kseq{}(inj{SortData{}, SortKItem{}}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortMutez{}, SortDataOrSeq{}}(VarM:SortMutez{}),Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(Lblmutez'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(),Lbl'Stop'List'LBraQuotUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList'QuotRBraUnds'AnnotationList{}()),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{})),dotk{}())),Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortData{}, SortDataOrSeq{}}(VarS:SortData{}),Lbl'Hash'StorageTypeFromContract'LParUndsRParUnds'MICHELSON-COMMON'Unds'Type'Unds'Contract{}(VarC:SortContract{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{})))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("398"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(398,8,405,9)"), UNIQUE'Unds'ID{}("3bce2caf5602c655c53fdc0b83b4502a8ae40c5233c8db86b354bdfabb00b87c")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{MapEntry,DataOrSeq}(`Elt___MICHELSON-COMMON-SYNTAX_MapEntry_Data_Data`(K,V)),`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(inj{MapTypeName,BinaryTypeName}(`map_MICHELSON-COMMON-SYNTAX_MapTypeName`(.KList)),_0,KT,VT),KnownAddrs,BigMaps,#Configuration)=>inj{Map,Data}(`_|->_`(inj{Data,KItem}(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Data,DataOrSeq}(K),KT,KnownAddrs,BigMaps,#Configuration)),inj{Data,KItem}(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Data,DataOrSeq}(V),VT,KnownAddrs,BigMaps,#Configuration)))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(e5c343ad19789294a6cdf429a7c24187eaf2682a8712882197e14ee0e37ff3e9), contentStartColumn(8), contentStartLine(374), org.kframework.attributes.Location(Location(374,8,375,105)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortMapEntry{}, SortDataOrSeq{}}(LblElt'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'MapEntry'Unds'Data'Unds'Data{}(VarK:SortData{},VarV:SortData{})),Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(inj{SortMapTypeName{}, SortBinaryTypeName{}}(Lblmap'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}()),Var'Unds'0:SortAnnotationList{},VarKT:SortType{},VarVT:SortType{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortMap{}, SortData{}}(Lbl'UndsPipe'-'-GT-Unds'{}(inj{SortData{}, SortKItem{}}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortData{}, SortDataOrSeq{}}(VarK:SortData{}),VarKT:SortType{},VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{})),inj{SortData{}, SortKItem{}}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortData{}, SortDataOrSeq{}}(VarV:SortData{}),VarVT:SortType{},VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}))))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("374"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(374,8,375,105)"), UNIQUE'Unds'ID{}("e5c343ad19789294a6cdf429a7c24187eaf2682a8712882197e14ee0e37ff3e9")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{OrData,DataOrSeq}(`Left__MICHELSON-COMMON-SYNTAX_OrData_Data`(V)),`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(`or_MICHELSON-COMMON-SYNTAX_BinaryTypeName`(.KList),_0,TL,_1),KnownAddrs,BigMaps,#Configuration)=>inj{OrData,Data}(`Left__MICHELSON-COMMON-SYNTAX_OrData_Data`(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Data,DataOrSeq}(V),TL,KnownAddrs,BigMaps,#Configuration))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(16d295bd576d01c6fd2ae168733352701b842cba501953c5aab95e34eb1a824f), contentStartColumn(8), contentStartLine(321), org.kframework.attributes.Location(Location(321,8,321,147)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortOrData{}, SortDataOrSeq{}}(LblLeft'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(VarV:SortData{})),Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(Lblor'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}(),Var'Unds'0:SortAnnotationList{},VarTL:SortType{},Var'Unds'1:SortType{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortOrData{}, SortData{}}(LblLeft'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortData{}, SortDataOrSeq{}}(VarV:SortData{}),VarTL:SortType{},VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{})))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("321"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(321,8,321,147)"), UNIQUE'Unds'ID{}("16d295bd576d01c6fd2ae168733352701b842cba501953c5aab95e34eb1a824f")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Pair,DataOrSeq}(`Pair___MICHELSON-COMMON-SYNTAX_Pair_Data_Data`(A,B)),`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(`pair_MICHELSON-COMMON-SYNTAX_BinaryTypeName`(.KList),_0,T1,T2),KnownAddrs,BigMaps,#Configuration)=>inj{Pair,Data}(`Pair___MICHELSON-COMMON-SYNTAX_Pair_Data_Data`(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Data,DataOrSeq}(A),T1,KnownAddrs,BigMaps,#Configuration),`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Data,DataOrSeq}(B),T2,KnownAddrs,BigMaps,#Configuration))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(7d2c98b0a3500fdac47d5a45388766a046a6205f04e06f68fed92993b231aefa), contentStartColumn(8), contentStartLine(315), org.kframework.attributes.Location(Location(315,8,316,106)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortPair{}, SortDataOrSeq{}}(LblPair'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Pair'Unds'Data'Unds'Data{}(VarA:SortData{},VarB:SortData{})),Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(Lblpair'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}(),Var'Unds'0:SortAnnotationList{},VarT1:SortType{},VarT2:SortType{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortPair{}, SortData{}}(LblPair'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Pair'Unds'Data'Unds'Data{}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortData{}, SortDataOrSeq{}}(VarA:SortData{}),VarT1:SortType{},VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}),Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortData{}, SortDataOrSeq{}}(VarB:SortData{}),VarT2:SortType{},VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{})))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("315"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(315,8,316,106)"), UNIQUE'Unds'ID{}("7d2c98b0a3500fdac47d5a45388766a046a6205f04e06f68fed92993b231aefa")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{OrData,DataOrSeq}(`Right__MICHELSON-COMMON-SYNTAX_OrData_Data`(V)),`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(`or_MICHELSON-COMMON-SYNTAX_BinaryTypeName`(.KList),_0,_1,TR),KnownAddrs,BigMaps,#Configuration)=>inj{OrData,Data}(`Right__MICHELSON-COMMON-SYNTAX_OrData_Data`(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Data,DataOrSeq}(V),TR,KnownAddrs,BigMaps,#Configuration))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(719366e7e41e690b61a07cc3c71436d62cb2fc47c3ee60da02a887e6c6f0f541), contentStartColumn(8), contentStartLine(322), org.kframework.attributes.Location(Location(322,8,322,148)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortOrData{}, SortDataOrSeq{}}(LblRight'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(VarV:SortData{})),Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(Lblor'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}(),Var'Unds'0:SortAnnotationList{},Var'Unds'1:SortType{},VarTR:SortType{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortOrData{}, SortData{}}(LblRight'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OrData'Unds'Data{}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortData{}, SortDataOrSeq{}}(VarV:SortData{}),VarTR:SortType{},VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{})))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("322"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(322,8,322,148)"), UNIQUE'Unds'ID{}("719366e7e41e690b61a07cc3c71436d62cb2fc47c3ee60da02a887e6c6f0f541")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{BlockchainOperation,DataOrSeq}(`Set_delegate(_,_)_MICHELSON-INTERNAL-SYNTAX_BlockchainOperation_Int_OptionData`(N,K)),`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(`operation_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList),_0),KnownAddrs,BigMaps,#Configuration)=>inj{BlockchainOperation,Data}(`Set_delegate(_,_)_MICHELSON-INTERNAL-SYNTAX_BlockchainOperation_Int_OptionData`(N,`project:OptionData`(inj{Data,KItem}(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{OptionData,DataOrSeq}(K),`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(`option_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList),`.List{"___MICHELSON-COMMON-SYNTAX_AnnotationList_Annotation_AnnotationList"}_AnnotationList`(.KList),`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(`key_hash_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList),`.List{"___MICHELSON-COMMON-SYNTAX_AnnotationList_Annotation_AnnotationList"}_AnnotationList`(.KList))),KnownAddrs,BigMaps,#Configuration))))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(9075cf6e64983870a7aecb5d66f322514e0f5fbac429825353aaf021e71d4071), contentStartColumn(8), contentStartLine(407), org.kframework.attributes.Location(Location(407,8,408,132)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortBlockchainOperation{}, SortDataOrSeq{}}(LblSet'Unds'delegate'LParUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'OptionData{}(VarN:SortInt{},VarK:SortOptionData{})),Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(Lbloperation'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(),Var'Unds'0:SortAnnotationList{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortBlockchainOperation{}, SortData{}}(LblSet'Unds'delegate'LParUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'OptionData{}(VarN:SortInt{},Lblproject'Coln'OptionData{}(kseq{}(inj{SortData{}, SortKItem{}}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortOptionData{}, SortDataOrSeq{}}(VarK:SortOptionData{}),Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Lbloption'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Lbl'Stop'List'LBraQuotUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList'QuotRBraUnds'AnnotationList{}(),Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(Lblkey'Unds'hash'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(),Lbl'Stop'List'LBraQuotUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList'QuotRBraUnds'AnnotationList{}())),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{})),dotk{}()))))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("407"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(407,8,408,132)"), UNIQUE'Unds'ID{}("9075cf6e64983870a7aecb5d66f322514e0f5fbac429825353aaf021e71d4071")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{OptionData,DataOrSeq}(`Some__MICHELSON-COMMON-SYNTAX_OptionData_Data`(V)),`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(`option_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList),_0,T),KnownAddrs,BigMaps,#Configuration)=>inj{OptionData,Data}(`Some__MICHELSON-COMMON-SYNTAX_OptionData_Data`(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Data,DataOrSeq}(V),T,KnownAddrs,BigMaps,#Configuration))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(5f6e9ac1225a77c312ecb93eedb1be879da1772bab9d9d17483f9770342ce295), contentStartColumn(8), contentStartLine(318), org.kframework.attributes.Location(Location(318,8,318,121)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortOptionData{}, SortDataOrSeq{}}(LblSome'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OptionData'Unds'Data{}(VarV:SortData{})),Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Lbloption'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'0:SortAnnotationList{},VarT:SortType{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortOptionData{}, SortData{}}(LblSome'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OptionData'Unds'Data{}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortData{}, SortDataOrSeq{}}(VarV:SortData{}),VarT:SortType{},VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{})))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("318"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(318,8,318,121)"), UNIQUE'Unds'ID{}("5f6e9ac1225a77c312ecb93eedb1be879da1772bab9d9d17483f9770342ce295")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{BlockchainOperation,DataOrSeq}(`Transfer_tokens(_,_,_,_)_MICHELSON-INTERNAL-SYNTAX_BlockchainOperation_Int_Data_Mutez_Address`(N,P,M,A)),`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(`operation_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList),_0),KnownAddrs,BigMaps,#Configuration)=>inj{BlockchainOperation,Data}(`Transfer_tokens(_,_,_,_)_MICHELSON-INTERNAL-SYNTAX_BlockchainOperation_Int_Data_Mutez_Address`(N,`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Data,DataOrSeq}(P),`#TypeFromOtherContract(_)_MICHELSON-COMMON_Type_ContractData`(`project:ContractData`(`Map:lookup`(KnownAddrs,inj{Data,KItem}(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Address,DataOrSeq}(A),`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(`address_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList),`.List{"___MICHELSON-COMMON-SYNTAX_AnnotationList_Annotation_AnnotationList"}_AnnotationList`(.KList)),KnownAddrs,BigMaps,#Configuration))))),KnownAddrs,BigMaps,#Configuration),`project:Mutez`(inj{Data,KItem}(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Mutez,DataOrSeq}(M),`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(`mutez_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList),`.List{"___MICHELSON-COMMON-SYNTAX_AnnotationList_Annotation_AnnotationList"}_AnnotationList`(.KList)),KnownAddrs,BigMaps,#Configuration))),`project:Address`(inj{Data,KItem}(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Address,DataOrSeq}(A),`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(`address_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList),`.List{"___MICHELSON-COMMON-SYNTAX_AnnotationList_Annotation_AnnotationList"}_AnnotationList`(.KList)),KnownAddrs,BigMaps,#Configuration))))) requires `_in_keys(_)_MAP_Bool_KItem_Map`(inj{Data,KItem}(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Address,DataOrSeq}(A),`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(`address_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList),`.List{"___MICHELSON-COMMON-SYNTAX_AnnotationList_Annotation_AnnotationList"}_AnnotationList`(.KList)),KnownAddrs,BigMaps,#Configuration)),KnownAddrs) ensures #token("true","Bool") [UNIQUE_ID(4d27b969e6218ecd87a3497e91d3821d26128c25874535ef22874f2545fb0c74), contentStartColumn(8), contentStartLine(425), org.kframework.attributes.Location(Location(425,8,436,104)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol])] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + Lbl'Unds'in'Unds'keys'LParUndsRParUnds'MAP'Unds'Bool'Unds'KItem'Unds'Map{}(inj{SortData{}, SortKItem{}}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortAddress{}, SortDataOrSeq{}}(VarA:SortAddress{}),Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(Lbladdress'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(),Lbl'Stop'List'LBraQuotUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList'QuotRBraUnds'AnnotationList{}()),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{})),VarKnownAddrs:SortMap{}), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortBlockchainOperation{}, SortDataOrSeq{}}(LblTransfer'Unds'tokens'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Data'Unds'Mutez'Unds'Address{}(VarN:SortInt{},VarP:SortData{},VarM:SortMutez{},VarA:SortAddress{})),Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(Lbloperation'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(),Var'Unds'0:SortAnnotationList{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortBlockchainOperation{}, SortData{}}(LblTransfer'Unds'tokens'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-INTERNAL-SYNTAX'Unds'BlockchainOperation'Unds'Int'Unds'Data'Unds'Mutez'Unds'Address{}(VarN:SortInt{},Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortData{}, SortDataOrSeq{}}(VarP:SortData{}),Lbl'Hash'TypeFromOtherContract'LParUndsRParUnds'MICHELSON-COMMON'Unds'Type'Unds'ContractData{}(Lblproject'Coln'ContractData{}(kseq{}(LblMap'Coln'lookup{}(VarKnownAddrs:SortMap{},inj{SortData{}, SortKItem{}}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortAddress{}, SortDataOrSeq{}}(VarA:SortAddress{}),Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(Lbladdress'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(),Lbl'Stop'List'LBraQuotUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList'QuotRBraUnds'AnnotationList{}()),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}))),dotk{}()))),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}),Lblproject'Coln'Mutez{}(kseq{}(inj{SortData{}, SortKItem{}}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortMutez{}, SortDataOrSeq{}}(VarM:SortMutez{}),Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(Lblmutez'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(),Lbl'Stop'List'LBraQuotUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList'QuotRBraUnds'AnnotationList{}()),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{})),dotk{}())),Lblproject'Coln'Address{}(kseq{}(inj{SortData{}, SortKItem{}}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortAddress{}, SortDataOrSeq{}}(VarA:SortAddress{}),Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(Lbladdress'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}(),Lbl'Stop'List'LBraQuotUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList'QuotRBraUnds'AnnotationList{}()),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{})),dotk{}()))))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("425"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(425,8,436,104)"), UNIQUE'Unds'ID{}("4d27b969e6218ecd87a3497e91d3821d26128c25874535ef22874f2545fb0c74")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{DataList,DataOrSeq}(`_;__MICHELSON-COMMON-SYNTAX_DataList_Data_DataList`(D1,`_;__MICHELSON-COMMON-SYNTAX_DataList_Data_DataList`(D2,DL) #as _3)),`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(`list_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList) #as _5,_0,T),KnownAddrs,BigMaps,#Configuration)=>inj{List,Data}(`_List_`(`ListItem`(inj{Data,KItem}(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Data,DataOrSeq}(D1),T,KnownAddrs,BigMaps,#Configuration))),`project:List`(inj{Data,KItem}(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{DataList,DataOrSeq}(_3),`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(_5,`.List{"___MICHELSON-COMMON-SYNTAX_AnnotationList_Annotation_AnnotationList"}_AnnotationList`(.KList),T),KnownAddrs,BigMaps,#Configuration))))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(a802b86719b1c118911e0a76d98cf976ded6f94e0787f6cb7ff97add433891b9), contentStartColumn(8), contentStartLine(343), org.kframework.attributes.Location(Location(343,8,344,145)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortDataList{}, SortDataOrSeq{}}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'DataList'Unds'Data'Unds'DataList{}(VarD1:SortData{},\and{SortDataList{}}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'DataList'Unds'Data'Unds'DataList{}(VarD2:SortData{},VarDL:SortDataList{}),Var'Unds'3:SortDataList{}))),Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(\and{SortUnaryTypeName{}}(Lbllist'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'5:SortUnaryTypeName{}),Var'Unds'0:SortAnnotationList{},VarT:SortType{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortList{}, SortData{}}(Lbl'Unds'List'Unds'{}(LblListItem{}(inj{SortData{}, SortKItem{}}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortData{}, SortDataOrSeq{}}(VarD1:SortData{}),VarT:SortType{},VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}))),Lblproject'Coln'List{}(kseq{}(inj{SortData{}, SortKItem{}}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortDataList{}, SortDataOrSeq{}}(Var'Unds'3:SortDataList{}),Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Var'Unds'5:SortUnaryTypeName{},Lbl'Stop'List'LBraQuotUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList'QuotRBraUnds'AnnotationList{}(),VarT:SortType{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{})),dotk{}()))))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("343"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(343,8,344,145)"), UNIQUE'Unds'ID{}("a802b86719b1c118911e0a76d98cf976ded6f94e0787f6cb7ff97add433891b9")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{DataList,DataOrSeq}(`_;__MICHELSON-COMMON-SYNTAX_DataList_Data_DataList`(D1,`_;__MICHELSON-COMMON-SYNTAX_DataList_Data_DataList`(D2,DL) #as _3)),`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(`set_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList) #as _5,_0,T),KnownAddrs,BigMaps,#Configuration)=>inj{Set,Data}(`_Set_`(`SetItem`(inj{Data,KItem}(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Data,DataOrSeq}(D1),T,KnownAddrs,BigMaps,#Configuration))),`project:Set`(inj{Data,KItem}(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{DataList,DataOrSeq}(_3),`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(_5,`.List{"___MICHELSON-COMMON-SYNTAX_AnnotationList_Annotation_AnnotationList"}_AnnotationList`(.KList),T),KnownAddrs,BigMaps,#Configuration))))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(6ec734a54e2391383304943d4f24cdc8bd698ce31028c82aff2adc66c1142f5c), contentStartColumn(8), contentStartLine(358), org.kframework.attributes.Location(Location(358,8,359,141)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortDataList{}, SortDataOrSeq{}}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'DataList'Unds'Data'Unds'DataList{}(VarD1:SortData{},\and{SortDataList{}}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'DataList'Unds'Data'Unds'DataList{}(VarD2:SortData{},VarDL:SortDataList{}),Var'Unds'3:SortDataList{}))),Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(\and{SortUnaryTypeName{}}(Lblset'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'5:SortUnaryTypeName{}),Var'Unds'0:SortAnnotationList{},VarT:SortType{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortSet{}, SortData{}}(Lbl'Unds'Set'Unds'{}(LblSetItem{}(inj{SortData{}, SortKItem{}}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortData{}, SortDataOrSeq{}}(VarD1:SortData{}),VarT:SortType{},VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}))),Lblproject'Coln'Set{}(kseq{}(inj{SortData{}, SortKItem{}}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortDataList{}, SortDataOrSeq{}}(Var'Unds'3:SortDataList{}),Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Var'Unds'5:SortUnaryTypeName{},Lbl'Stop'List'LBraQuotUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList'QuotRBraUnds'AnnotationList{}(),VarT:SortType{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{})),dotk{}()))))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("358"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(358,8,359,141)"), UNIQUE'Unds'ID{}("6ec734a54e2391383304943d4f24cdc8bd698ce31028c82aff2adc66c1142f5c")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{DataList,DataOrSeq}(`_;__MICHELSON-COMMON-SYNTAX_DataList_Data_DataList`(D1,inj{Data,DataList}(D2))),`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(`list_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList),_0,T),KnownAddrs,BigMaps,#Configuration)=>inj{List,Data}(`_List_`(`ListItem`(inj{Data,KItem}(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Data,DataOrSeq}(D1),T,KnownAddrs,BigMaps,#Configuration))),`ListItem`(inj{Data,KItem}(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Data,DataOrSeq}(D2),T,KnownAddrs,BigMaps,#Configuration))))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(1a5c96e0e40d17c0fb5898f79d8c6feb7117e0265a14ffd5d19224c0b5204c7a), contentStartColumn(8), contentStartLine(340), org.kframework.attributes.Location(Location(340,8,341,121)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortDataList{}, SortDataOrSeq{}}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'DataList'Unds'Data'Unds'DataList{}(VarD1:SortData{},inj{SortData{}, SortDataList{}}(VarD2:SortData{}))),Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Lbllist'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'0:SortAnnotationList{},VarT:SortType{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortList{}, SortData{}}(Lbl'Unds'List'Unds'{}(LblListItem{}(inj{SortData{}, SortKItem{}}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortData{}, SortDataOrSeq{}}(VarD1:SortData{}),VarT:SortType{},VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}))),LblListItem{}(inj{SortData{}, SortKItem{}}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortData{}, SortDataOrSeq{}}(VarD2:SortData{}),VarT:SortType{},VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{})))))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("340"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(340,8,341,121)"), UNIQUE'Unds'ID{}("1a5c96e0e40d17c0fb5898f79d8c6feb7117e0265a14ffd5d19224c0b5204c7a")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{DataList,DataOrSeq}(`_;__MICHELSON-COMMON-SYNTAX_DataList_Data_DataList`(D1,inj{Data,DataList}(D2))),`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(`set_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList),_0,T),KnownAddrs,BigMaps,#Configuration)=>inj{Set,Data}(`_Set_`(`SetItem`(inj{Data,KItem}(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Data,DataOrSeq}(D1),T,KnownAddrs,BigMaps,#Configuration))),`SetItem`(inj{Data,KItem}(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Data,DataOrSeq}(D2),T,KnownAddrs,BigMaps,#Configuration))))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(2592b5128be5e4652b08bce7454b80878273c9f6ca2383ba447db64fdd03085d), contentStartColumn(8), contentStartLine(355), org.kframework.attributes.Location(Location(355,8,356,119)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortDataList{}, SortDataOrSeq{}}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'DataList'Unds'Data'Unds'DataList{}(VarD1:SortData{},inj{SortData{}, SortDataList{}}(VarD2:SortData{}))),Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Lblset'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'0:SortAnnotationList{},VarT:SortType{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortSet{}, SortData{}}(Lbl'Unds'Set'Unds'{}(LblSetItem{}(inj{SortData{}, SortKItem{}}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortData{}, SortDataOrSeq{}}(VarD1:SortData{}),VarT:SortType{},VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}))),LblSetItem{}(inj{SortData{}, SortKItem{}}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortData{}, SortDataOrSeq{}}(VarD2:SortData{}),VarT:SortType{},VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{})))))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("355"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(355,8,356,119)"), UNIQUE'Unds'ID{}("2592b5128be5e4652b08bce7454b80878273c9f6ca2383ba447db64fdd03085d")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{MapEntryList,DataOrSeq}(`_;__MICHELSON-COMMON-SYNTAX_MapEntryList_MapEntry_MapEntryList`(`Elt___MICHELSON-COMMON-SYNTAX_MapEntry_Data_Data`(K,V),ML)),`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(inj{MapTypeName,BinaryTypeName}(`map_MICHELSON-COMMON-SYNTAX_MapTypeName`(.KList)) #as _5,_0,KT,VT),KnownAddrs,BigMaps,#Configuration)=>inj{Map,Data}(`Map:update`(`project:Map`(inj{Data,KItem}(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{MapEntryList,DataOrSeq}(ML),`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(_5,`.List{"___MICHELSON-COMMON-SYNTAX_AnnotationList_Annotation_AnnotationList"}_AnnotationList`(.KList),KT,VT),KnownAddrs,BigMaps,#Configuration))),inj{Data,KItem}(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Data,DataOrSeq}(K),KT,KnownAddrs,BigMaps,#Configuration)),inj{Data,KItem}(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Data,DataOrSeq}(V),VT,KnownAddrs,BigMaps,#Configuration)))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(44c7c2f85e666badfe65f0fd81f4ccd6d4e902a4ba6382f37d6e93c050ab683e), contentStartColumn(8), contentStartLine(371), org.kframework.attributes.Location(Location(371,8,372,185)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortMapEntryList{}, SortDataOrSeq{}}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'MapEntryList'Unds'MapEntry'Unds'MapEntryList{}(LblElt'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'MapEntry'Unds'Data'Unds'Data{}(VarK:SortData{},VarV:SortData{}),VarML:SortMapEntryList{})),Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(\and{SortBinaryTypeName{}}(inj{SortMapTypeName{}, SortBinaryTypeName{}}(Lblmap'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}()),Var'Unds'5:SortBinaryTypeName{}),Var'Unds'0:SortAnnotationList{},VarKT:SortType{},VarVT:SortType{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortMap{}, SortData{}}(LblMap'Coln'update{}(Lblproject'Coln'Map{}(kseq{}(inj{SortData{}, SortKItem{}}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortMapEntryList{}, SortDataOrSeq{}}(VarML:SortMapEntryList{}),Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(Var'Unds'5:SortBinaryTypeName{},Lbl'Stop'List'LBraQuotUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList'QuotRBraUnds'AnnotationList{}(),VarKT:SortType{},VarVT:SortType{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{})),dotk{}())),inj{SortData{}, SortKItem{}}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortData{}, SortDataOrSeq{}}(VarK:SortData{}),VarKT:SortType{},VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{})),inj{SortData{}, SortKItem{}}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortData{}, SortDataOrSeq{}}(VarV:SortData{}),VarVT:SortType{},VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}))))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("371"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(371,8,372,185)"), UNIQUE'Unds'ID{}("44c7c2f85e666badfe65f0fd81f4ccd6d4e902a4ba6382f37d6e93c050ab683e")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Block,DataOrSeq}(`{_}_MICHELSON-COMMON-SYNTAX_Block_DataList`(`_;__MICHELSON-COMMON-SYNTAX_DataList_Data_DataList`(D1,DL) #as _3)),`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(`list_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList) #as _5,_0,T),KnownAddrs,BigMaps,#Configuration)=>`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{DataList,DataOrSeq}(_3),`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(_5,`.List{"___MICHELSON-COMMON-SYNTAX_AnnotationList_Annotation_AnnotationList"}_AnnotationList`(.KList),T),KnownAddrs,BigMaps,#Configuration) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(1018077d3734083f14bd264cd42fcc420046bb72fb6a53a1d9894e8859a27811), contentStartColumn(8), contentStartLine(338), org.kframework.attributes.Location(Location(338,8,338,155)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortBlock{}, SortDataOrSeq{}}(Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Block'Unds'DataList{}(\and{SortDataList{}}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'DataList'Unds'Data'Unds'DataList{}(VarD1:SortData{},VarDL:SortDataList{}),Var'Unds'3:SortDataList{}))),Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(\and{SortUnaryTypeName{}}(Lbllist'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'5:SortUnaryTypeName{}),Var'Unds'0:SortAnnotationList{},VarT:SortType{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortDataList{}, SortDataOrSeq{}}(Var'Unds'3:SortDataList{}),Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Var'Unds'5:SortUnaryTypeName{},Lbl'Stop'List'LBraQuotUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList'QuotRBraUnds'AnnotationList{}(),VarT:SortType{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("338"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(338,8,338,155)"), UNIQUE'Unds'ID{}("1018077d3734083f14bd264cd42fcc420046bb72fb6a53a1d9894e8859a27811")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Block,DataOrSeq}(`{_}_MICHELSON-COMMON-SYNTAX_Block_DataList`(`_;__MICHELSON-COMMON-SYNTAX_DataList_Data_DataList`(D1,DL) #as _3)),`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(`set_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList) #as _5,_0,T),KnownAddrs,BigMaps,#Configuration)=>`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{DataList,DataOrSeq}(_3),`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(_5,`.List{"___MICHELSON-COMMON-SYNTAX_AnnotationList_Annotation_AnnotationList"}_AnnotationList`(.KList),T),KnownAddrs,BigMaps,#Configuration) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(901ab66485e6f8370ebf1f1cfbfc6a7f8966827d340ca80f341d3ed7882c6fad), contentStartColumn(8), contentStartLine(353), org.kframework.attributes.Location(Location(353,8,353,153)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortBlock{}, SortDataOrSeq{}}(Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Block'Unds'DataList{}(\and{SortDataList{}}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'DataList'Unds'Data'Unds'DataList{}(VarD1:SortData{},VarDL:SortDataList{}),Var'Unds'3:SortDataList{}))),Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(\and{SortUnaryTypeName{}}(Lblset'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'5:SortUnaryTypeName{}),Var'Unds'0:SortAnnotationList{},VarT:SortType{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortDataList{}, SortDataOrSeq{}}(Var'Unds'3:SortDataList{}),Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Var'Unds'5:SortUnaryTypeName{},Lbl'Stop'List'LBraQuotUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList'QuotRBraUnds'AnnotationList{}(),VarT:SortType{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("353"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(353,8,353,153)"), UNIQUE'Unds'ID{}("901ab66485e6f8370ebf1f1cfbfc6a7f8966827d340ca80f341d3ed7882c6fad")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Block,DataOrSeq}(`{_}_MICHELSON-COMMON-SYNTAX_Block_DataList`(inj{Data,DataList}(D))),`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(`set_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList),_0,T),KnownAddrs,BigMaps,#Configuration)=>inj{Set,Data}(`SetItem`(inj{Data,KItem}(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Data,DataOrSeq}(D),T,KnownAddrs,BigMaps,#Configuration)))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(147aa5edab0ac6d3a9320a174eb81278b3b8c9dbe203d1a563d18edd99ba3f1f), contentStartColumn(8), contentStartLine(352), org.kframework.attributes.Location(Location(352,8,352,126)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortBlock{}, SortDataOrSeq{}}(Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Block'Unds'DataList{}(inj{SortData{}, SortDataList{}}(VarD:SortData{}))),Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Lblset'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'0:SortAnnotationList{},VarT:SortType{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortSet{}, SortData{}}(LblSetItem{}(inj{SortData{}, SortKItem{}}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortData{}, SortDataOrSeq{}}(VarD:SortData{}),VarT:SortType{},VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}))))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("352"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(352,8,352,126)"), UNIQUE'Unds'ID{}("147aa5edab0ac6d3a9320a174eb81278b3b8c9dbe203d1a563d18edd99ba3f1f")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Block,DataOrSeq}(`{_}_MICHELSON-COMMON-SYNTAX_Block_DataList`(inj{Data,DataList}(D1))),`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(`list_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList),_0,T),KnownAddrs,BigMaps,#Configuration)=>inj{List,Data}(`ListItem`(inj{Data,KItem}(`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Data,DataOrSeq}(D1),T,KnownAddrs,BigMaps,#Configuration)))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(1ab72a749964df215535cf7fe24314bbb78fda7f8fa598b0c28e059bf4e43e6b), contentStartColumn(8), contentStartLine(337), org.kframework.attributes.Location(Location(337,8,337,130)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortBlock{}, SortDataOrSeq{}}(Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'Block'Unds'DataList{}(inj{SortData{}, SortDataList{}}(VarD1:SortData{}))),Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Lbllist'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'0:SortAnnotationList{},VarT:SortType{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortList{}, SortData{}}(LblListItem{}(inj{SortData{}, SortKItem{}}(Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortData{}, SortDataOrSeq{}}(VarD1:SortData{}),VarT:SortType{},VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}))))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("337"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(337,8,337,130)"), UNIQUE'Unds'ID{}("1ab72a749964df215535cf7fe24314bbb78fda7f8fa598b0c28e059bf4e43e6b")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{MapLiteral,DataOrSeq}(`{_}_MICHELSON-COMMON-SYNTAX_MapLiteral_MapEntryList`(M)),`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(inj{MapTypeName,BinaryTypeName}(`map_MICHELSON-COMMON-SYNTAX_MapTypeName`(.KList)) #as _4,_0,KT,VT),KnownAddrs,BigMaps,#Configuration)=>`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{MapEntryList,DataOrSeq}(M),`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(_4,`.List{"___MICHELSON-COMMON-SYNTAX_AnnotationList_Annotation_AnnotationList"}_AnnotationList`(.KList),KT,VT),KnownAddrs,BigMaps,#Configuration) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(e75e9534ca27745327c87bf935c8909e3ee74c13e502edeb81f4dce25892cbe4), contentStartColumn(8), contentStartLine(368), org.kframework.attributes.Location(Location(368,8,369,77)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortMapLiteral{}, SortDataOrSeq{}}(Lbl'LBraUndsRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'MapLiteral'Unds'MapEntryList{}(VarM:SortMapEntryList{})),Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(\and{SortBinaryTypeName{}}(inj{SortMapTypeName{}, SortBinaryTypeName{}}(Lblmap'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}()),Var'Unds'4:SortBinaryTypeName{}),Var'Unds'0:SortAnnotationList{},VarKT:SortType{},VarVT:SortType{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortMapEntryList{}, SortDataOrSeq{}}(VarM:SortMapEntryList{}),Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(Var'Unds'4:SortBinaryTypeName{},Lbl'Stop'List'LBraQuotUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList'QuotRBraUnds'AnnotationList{}(),VarKT:SortType{},VarVT:SortType{}),VarKnownAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("368"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(368,8,369,77)"), UNIQUE'Unds'ID{}("e75e9534ca27745327c87bf935c8909e3ee74c13e502edeb81f4dce25892cbe4")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{EmptyBlock,DataOrSeq}(`{}_MICHELSON-COMMON-SYNTAX_EmptyBlock`(.KList)),`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(`list_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList),_0,_1),_KnownAddrs,_BigMaps,#Configuration)=>inj{List,Data}(`.List`(.KList)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(652af4b6ac0a53282940d0a133e1fa03e1d4fb3f765ce4019336ef694841d124), contentStartColumn(8), contentStartLine(336), org.kframework.attributes.Location(Location(336,8,336,73)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortEmptyBlock{}, SortDataOrSeq{}}(Lbl'LBraRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'EmptyBlock{}()),Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Lbllist'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'0:SortAnnotationList{},Var'Unds'1:SortType{}),Var'Unds'KnownAddrs:SortMap{},Var'Unds'BigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortList{}, SortData{}}(Lbl'Stop'List{}())), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("336"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(336,8,336,73)"), UNIQUE'Unds'ID{}("652af4b6ac0a53282940d0a133e1fa03e1d4fb3f765ce4019336ef694841d124")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{EmptyBlock,DataOrSeq}(`{}_MICHELSON-COMMON-SYNTAX_EmptyBlock`(.KList)),`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(`set_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList),_0,_1),_KnownAddrs,_BigMaps,#Configuration)=>inj{Set,Data}(`.Set`(.KList)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(b131e8a71e28f9f9ca0e9724e3e872f0492498b789a4431fad8c8c2259dc3dc7), contentStartColumn(8), contentStartLine(351), org.kframework.attributes.Location(Location(351,8,351,71)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortEmptyBlock{}, SortDataOrSeq{}}(Lbl'LBraRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'EmptyBlock{}()),Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(Lblset'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Var'Unds'0:SortAnnotationList{},Var'Unds'1:SortType{}),Var'Unds'KnownAddrs:SortMap{},Var'Unds'BigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortSet{}, SortData{}}(Lbl'Stop'Set{}())), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("351"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(351,8,351,71)"), UNIQUE'Unds'ID{}("b131e8a71e28f9f9ca0e9724e3e872f0492498b789a4431fad8c8c2259dc3dc7")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{EmptyBlock,DataOrSeq}(`{}_MICHELSON-COMMON-SYNTAX_EmptyBlock`(.KList)),`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(inj{MapTypeName,BinaryTypeName}(`big_map_MICHELSON-COMMON-SYNTAX_MapTypeName`(.KList)),_0,_K,_V),_KnownAddrs,_BigMaps,#Configuration)=>inj{Map,Data}(`.Map`(.KList)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(362fd1fc7289e86aed15292b9ac918622f496ac9156c3c3dc10257e23d2dfcbd), contentStartColumn(8), contentStartLine(377), org.kframework.attributes.Location(Location(377,8,377,94)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortEmptyBlock{}, SortDataOrSeq{}}(Lbl'LBraRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'EmptyBlock{}()),Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(inj{SortMapTypeName{}, SortBinaryTypeName{}}(Lblbig'Unds'map'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}()),Var'Unds'0:SortAnnotationList{},Var'Unds'K:SortType{},Var'Unds'V:SortType{}),Var'Unds'KnownAddrs:SortMap{},Var'Unds'BigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortMap{}, SortData{}}(Lbl'Stop'Map{}())), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("377"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(377,8,377,94)"), UNIQUE'Unds'ID{}("362fd1fc7289e86aed15292b9ac918622f496ac9156c3c3dc10257e23d2dfcbd")] + +// rule `#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{EmptyBlock,DataOrSeq}(`{}_MICHELSON-COMMON-SYNTAX_EmptyBlock`(.KList)),`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(inj{MapTypeName,BinaryTypeName}(`map_MICHELSON-COMMON-SYNTAX_MapTypeName`(.KList)),_0,_1,_2),_KnownAddrs,_BigMaps,#Configuration)=>inj{Map,Data}(`.Map`(.KList)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(c7815dc80cc94fd69b9421801fc6abd1bd8bc4f904df24efcc2159aabbf163bc), contentStartColumn(8), contentStartLine(367), org.kframework.attributes.Location(Location(367,8,367,73)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortEmptyBlock{}, SortDataOrSeq{}}(Lbl'LBraRBraUnds'MICHELSON-COMMON-SYNTAX'Unds'EmptyBlock{}()),Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(inj{SortMapTypeName{}, SortBinaryTypeName{}}(Lblmap'Unds'MICHELSON-COMMON-SYNTAX'Unds'MapTypeName{}()),Var'Unds'0:SortAnnotationList{},Var'Unds'1:SortType{},Var'Unds'2:SortType{}),Var'Unds'KnownAddrs:SortMap{},Var'Unds'BigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortMap{}, SortData{}}(Lbl'Stop'Map{}())), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("367"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(367,8,367,73)"), UNIQUE'Unds'ID{}("c7815dc80cc94fd69b9421801fc6abd1bd8bc4f904df24efcc2159aabbf163bc")] + +// rule `#MinKey(_)_MICHELSON_Data_Map`(M)=>`#MinimalElement(_)_MICHELSON_Data_List`(`keys_list(_)_MAP_List_Map`(M)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(ca75d598d0145162dc815ee1a10afdbd37645f545028e56c6553d09353985010), contentStartColumn(8), contentStartLine(1511), org.kframework.attributes.Location(Location(1505,8,1505,51)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MinKey'LParUndsRParUnds'MICHELSON'Unds'Data'Unds'Map{}(VarM:SortMap{}), + Lbl'Hash'MinimalElement'LParUndsRParUnds'MICHELSON'Unds'Data'Unds'List{}(Lblkeys'Unds'list'LParUndsRParUnds'MAP'Unds'List'Unds'Map{}(VarM:SortMap{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1511"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1505,8,1505,51)"), UNIQUE'Unds'ID{}("ca75d598d0145162dc815ee1a10afdbd37645f545028e56c6553d09353985010")] + +// rule `#MinimalElement(_)_MICHELSON_Data_List`(`_List_`(`ListItem`(inj{Data,KItem}(H)),L))=>`#MinimalElementAux(_,_)_MICHELSON_Data_List_Data`(L,H) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(2c78abd765e713ef64394f3e0046762ceaa511812b604efbcd3687fcfbfa07ee), contentStartColumn(8), contentStartLine(1377), org.kframework.attributes.Location(Location(1371,8,1371,66)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MinimalElement'LParUndsRParUnds'MICHELSON'Unds'Data'Unds'List{}(Lbl'Unds'List'Unds'{}(LblListItem{}(inj{SortData{}, SortKItem{}}(VarH:SortData{})),VarL:SortList{})), + Lbl'Hash'MinimalElementAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Data'Unds'List'Unds'Data{}(VarL:SortList{},VarH:SortData{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1377"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1371,8,1371,66)"), UNIQUE'Unds'ID{}("2c78abd765e713ef64394f3e0046762ceaa511812b604efbcd3687fcfbfa07ee")] + +// rule `#MinimalElementAux(_,_)_MICHELSON_Data_List_Data`(`.List`(.KList),M)=>M requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(32192010c9583e7c82406aa9f87b71218605d6b7e7f7b9a539825a816db1a5ca), contentStartColumn(8), contentStartLine(1378), org.kframework.attributes.Location(Location(1372,8,1372,41)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MinimalElementAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Data'Unds'List'Unds'Data{}(Lbl'Stop'List{}(),VarM:SortData{}), + VarM:SortData{}), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1378"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1372,8,1372,41)"), UNIQUE'Unds'ID{}("32192010c9583e7c82406aa9f87b71218605d6b7e7f7b9a539825a816db1a5ca")] + +// rule `#MinimalElementAux(_,_)_MICHELSON_Data_List_Data`(`_List_`(`ListItem`(inj{Data,KItem}(H)),L),M)=>`#MinimalElementAux(_,_)_MICHELSON_Data_List_Data`(L,H) requires `_==Int_`(`#DoCompare(_,_)_MICHELSON_Int_Data_Data`(M,H),#token("1","Int")) ensures #token("true","Bool") [UNIQUE_ID(068f2e4e2ab513abad18da02aff9b26c4e06a423b5e212266200b276ee082953), contentStartColumn(8), contentStartLine(1381), org.kframework.attributes.Location(Location(1375,8,1376,66)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol])] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + Lbl'UndsEqlsEqls'Int'Unds'{}(Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(VarM:SortData{},VarH:SortData{}),\dv{SortInt{}}("1")), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MinimalElementAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Data'Unds'List'Unds'Data{}(Lbl'Unds'List'Unds'{}(LblListItem{}(inj{SortData{}, SortKItem{}}(VarH:SortData{})),VarL:SortList{}),VarM:SortData{}), + Lbl'Hash'MinimalElementAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Data'Unds'List'Unds'Data{}(VarL:SortList{},VarH:SortData{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("1381"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1375,8,1376,66)"), UNIQUE'Unds'ID{}("068f2e4e2ab513abad18da02aff9b26c4e06a423b5e212266200b276ee082953")] + +// rule `#MinimalElementAux(_,_)_MICHELSON_Data_List_Data`(`_List_`(`ListItem`(inj{Data,KItem}(H)),L),M)=>`#MinimalElementAux(_,_)_MICHELSON_Data_List_Data`(L,M) requires `_<=Int_`(`#DoCompare(_,_)_MICHELSON_Int_Data_Data`(M,H),#token("0","Int")) ensures #token("true","Bool") [UNIQUE_ID(cde572223d56bc76f3ff92ce8cf7ca35a63023a4cd59d43203df6d6f073d7348), contentStartColumn(8), contentStartLine(1379), org.kframework.attributes.Location(Location(1373,8,1374,66)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol])] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + Lbl'Unds-LT-Eqls'Int'Unds'{}(Lbl'Hash'DoCompare'LParUndsCommUndsRParUnds'MICHELSON'Unds'Int'Unds'Data'Unds'Data{}(VarM:SortData{},VarH:SortData{}),\dv{SortInt{}}("0")), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortData{},R} ( + Lbl'Hash'MinimalElementAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Data'Unds'List'Unds'Data{}(Lbl'Unds'List'Unds'{}(LblListItem{}(inj{SortData{}, SortKItem{}}(VarH:SortData{})),VarL:SortList{}),VarM:SortData{}), + Lbl'Hash'MinimalElementAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'Data'Unds'List'Unds'Data{}(VarL:SortList{},VarM:SortData{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("1379"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1373,8,1374,66)"), UNIQUE'Unds'ID{}("cde572223d56bc76f3ff92ce8cf7ca35a63023a4cd59d43203df6d6f073d7348")] + +// rule `#MutezOverflowLimit_MICHELSON-COMMON_Int`(.KList)=>`_^Int_`(#token("2","Int"),#token("63","Int")) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(8a36f0749432411e981ea3d08f3bc6dbfd406a9ddfc6583bfea52ec64f02dc62), contentStartColumn(8), contentStartLine(145), org.kframework.attributes.Location(Location(145,8,145,40)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortInt{},R} ( + Lbl'Hash'MutezOverflowLimit'Unds'MICHELSON-COMMON'Unds'Int{}(), + Lbl'UndsXor-'Int'Unds'{}(\dv{SortInt{}}("2"),\dv{SortInt{}}("63"))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("145"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(145,8,145,40)"), UNIQUE'Unds'ID{}("8a36f0749432411e981ea3d08f3bc6dbfd406a9ddfc6583bfea52ec64f02dc62")] + +// rule `#Name(_)_MICHELSON-COMMON_TypeName_Type`(`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(T,_0))=>inj{NullaryTypeName,TypeName}(T) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(0a532c7d4ad528cce0a1080bf4ed82e25ddcc37f36f0c6700596fe4a36c25d8b), contentStartColumn(8), contentStartLine(26), org.kframework.attributes.Location(Location(26,8,26,54)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortTypeName{},R} ( + Lbl'Hash'Name'LParUndsRParUnds'MICHELSON-COMMON'Unds'TypeName'Unds'Type{}(Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(VarT:SortNullaryTypeName{},Var'Unds'0:SortAnnotationList{})), + inj{SortNullaryTypeName{}, SortTypeName{}}(VarT:SortNullaryTypeName{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("26"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(26,8,26,54)"), UNIQUE'Unds'ID{}("0a532c7d4ad528cce0a1080bf4ed82e25ddcc37f36f0c6700596fe4a36c25d8b")] + +// rule `#Name(_)_MICHELSON-COMMON_TypeName_Type`(`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(T,_0,ArgT))=>`___MICHELSON-COMMON_TypeName_UnaryTypeName_TypeName`(T,`#Name(_)_MICHELSON-COMMON_TypeName_Type`(ArgT)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(a5719245e581d606e73633b1ff725138165587a140984d9ef14c1843a045b2de), contentStartColumn(8), contentStartLine(27), org.kframework.attributes.Location(Location(27,8,27,69)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortTypeName{},R} ( + Lbl'Hash'Name'LParUndsRParUnds'MICHELSON-COMMON'Unds'TypeName'Unds'Type{}(Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(VarT:SortUnaryTypeName{},Var'Unds'0:SortAnnotationList{},VarArgT:SortType{})), + Lbl'UndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'UnaryTypeName'Unds'TypeName{}(VarT:SortUnaryTypeName{},Lbl'Hash'Name'LParUndsRParUnds'MICHELSON-COMMON'Unds'TypeName'Unds'Type{}(VarArgT:SortType{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("27"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(27,8,27,69)"), UNIQUE'Unds'ID{}("a5719245e581d606e73633b1ff725138165587a140984d9ef14c1843a045b2de")] + +// rule `#Name(_)_MICHELSON-COMMON_TypeName_Type`(`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(T,_0,ArgT1,ArgT2))=>`____MICHELSON-COMMON_TypeName_BinaryTypeName_TypeName_TypeName`(T,`#Name(_)_MICHELSON-COMMON_TypeName_Type`(ArgT1),`#Name(_)_MICHELSON-COMMON_TypeName_Type`(ArgT2)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(e9d277ca1b0791d4eae0be7d8d719122b012fae4533d56aff13163dafa90775a), contentStartColumn(8), contentStartLine(28), org.kframework.attributes.Location(Location(28,8,28,91)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortTypeName{},R} ( + Lbl'Hash'Name'LParUndsRParUnds'MICHELSON-COMMON'Unds'TypeName'Unds'Type{}(Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(VarT:SortBinaryTypeName{},Var'Unds'0:SortAnnotationList{},VarArgT1:SortType{},VarArgT2:SortType{})), + Lbl'UndsUndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'BinaryTypeName'Unds'TypeName'Unds'TypeName{}(VarT:SortBinaryTypeName{},Lbl'Hash'Name'LParUndsRParUnds'MICHELSON-COMMON'Unds'TypeName'Unds'Type{}(VarArgT1:SortType{}),Lbl'Hash'Name'LParUndsRParUnds'MICHELSON-COMMON'Unds'TypeName'Unds'Type{}(VarArgT2:SortType{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("28"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(28,8,28,91)"), UNIQUE'Unds'ID{}("e9d277ca1b0791d4eae0be7d8d719122b012fae4533d56aff13163dafa90775a")] + +// rule `#NextNonce(_)_MICHELSON_OperationNonce_OperationNonce`(`#Nonce(_)_MICHELSON-COMMON_OperationNonce_Int`(I))=>`#Nonce(_)_MICHELSON-COMMON_OperationNonce_Int`(`_+Int_`(I,#token("1","Int"))) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(479cc81e403cf32821e23c2a7e1cf3ea8b915000aaa51bfbc3a47e2aca81a7f1), contentStartColumn(8), contentStartLine(1714), org.kframework.attributes.Location(Location(1708,8,1708,49)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortOperationNonce{},R} ( + Lbl'Hash'NextNonce'LParUndsRParUnds'MICHELSON'Unds'OperationNonce'Unds'OperationNonce{}(Lbl'Hash'Nonce'LParUndsRParUnds'MICHELSON-COMMON'Unds'OperationNonce'Unds'Int{}(VarI:SortInt{})), + Lbl'Hash'Nonce'LParUndsRParUnds'MICHELSON-COMMON'Unds'OperationNonce'Unds'Int{}(Lbl'UndsPlus'Int'Unds'{}(VarI:SortInt{},\dv{SortInt{}}("1")))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1714"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1708,8,1708,49)"), UNIQUE'Unds'ID{}("479cc81e403cf32821e23c2a7e1cf3ea8b915000aaa51bfbc3a47e2aca81a7f1")] + +// rule `#NotEq(_,_,_)_MICHELSON_Bool_TypeName_Data_Data`(_0,V1,V2)=>`_=/=K_`(inj{Data,KItem}(V1),inj{Data,KItem}(V2)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(3c75e02230a270eada88b7d6a80e00f78d550747ee388898240274962d88fd4d), contentStartColumn(8), contentStartLine(1421), org.kframework.attributes.Location(Location(1415,8,1415,43)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]), owise] + axiom{R} \implies{R} ( + \and{R} ( + \not{R} ( + \or{R} ( + \exists{R} (Var'Unds'2:SortInt{}, + \exists{R} (Var'Unds'1:SortInt{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortTypeName{}, R} ( + \and{SortTypeName{}} ( + Var'Unds'0:SortTypeName{}, + inj{SortNumTypeName{}, SortTypeName{}}(Lblint'Unds'MICHELSON-COMMON-SYNTAX'Unds'NumTypeName{}()) + )),\and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarV1:SortData{}, + inj{SortInt{}, SortData{}}(Var'Unds'1:SortInt{}) + )),\and{R} ( + \ceil{SortData{}, R} ( + \and{SortData{}} ( + VarV2:SortData{}, + inj{SortInt{}, SortData{}}(Var'Unds'2:SortInt{}) + )), + \top{R} () + ))) + ))), + \bottom{R}() + ) + ), + \top{R}() + ), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'NotEq'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName'Unds'Data'Unds'Data{}(Var'Unds'0:SortTypeName{},VarV1:SortData{},VarV2:SortData{}), + Lbl'UndsEqlsSlshEqls'K'Unds'{}(kseq{}(inj{SortData{}, SortKItem{}}(VarV1:SortData{}),dotk{}()),kseq{}(inj{SortData{}, SortKItem{}}(VarV2:SortData{}),dotk{}()))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1421"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1415,8,1415,43)"), owise{}(), UNIQUE'Unds'ID{}("3c75e02230a270eada88b7d6a80e00f78d550747ee388898240274962d88fd4d")] + +// rule `#NotEq(_,_,_)_MICHELSON_Bool_TypeName_Data_Data`(inj{NumTypeName,TypeName}(`int_MICHELSON-COMMON-SYNTAX_NumTypeName`(.KList)),inj{Int,Data}(V1),inj{Int,Data}(V2))=>`_=/=Int_`(V1,V2) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(8e6e40a49dd53b07333db759b874e8fce2602216977801ca9fd213b97c83ca40), contentStartColumn(8), contentStartLine(1420), org.kframework.attributes.Location(Location(1414,8,1414,43)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBool{},R} ( + Lbl'Hash'NotEq'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName'Unds'Data'Unds'Data{}(inj{SortNumTypeName{}, SortTypeName{}}(Lblint'Unds'MICHELSON-COMMON-SYNTAX'Unds'NumTypeName{}()),inj{SortInt{}, SortData{}}(VarV1:SortInt{}),inj{SortInt{}, SortData{}}(VarV2:SortInt{})), + Lbl'UndsEqlsSlshEqls'Int'Unds'{}(VarV1:SortInt{},VarV2:SortInt{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1420"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1414,8,1414,43)"), UNIQUE'Unds'ID{}("8e6e40a49dd53b07333db759b874e8fce2602216977801ca9fd213b97c83ca40")] + +// rule `#OtherContractsMapEntryListToKMap(_)_MICHELSON-COMMON_Map_OtherContractsMapEntryList`(`.List{"_;__MICHELSON-COMMON-SYNTAX_OtherContractsMapEntryList_OtherContractsMapEntry_OtherContractsMapEntryList"}_OtherContractsMapEntryList`(.KList))=>`.Map`(.KList) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(eff932a623c45a2aa402e4d2b6b99e8344ad4471cc8fd362cc67a998871c345f), contentStartColumn(8), contentStartLine(187), org.kframework.attributes.Location(Location(187,8,187,80)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortMap{},R} ( + Lbl'Hash'OtherContractsMapEntryListToKMap'LParUndsRParUnds'MICHELSON-COMMON'Unds'Map'Unds'OtherContractsMapEntryList{}(Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OtherContractsMapEntryList'Unds'OtherContractsMapEntry'Unds'OtherContractsMapEntryList'QuotRBraUnds'OtherContractsMapEntryList{}()), + Lbl'Stop'Map{}()), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("187"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(187,8,187,80)"), UNIQUE'Unds'ID{}("eff932a623c45a2aa402e4d2b6b99e8344ad4471cc8fd362cc67a998871c345f")] + +// rule `#OtherContractsMapEntryListToKMap(_)_MICHELSON-COMMON_Map_OtherContractsMapEntryList`(`_;__MICHELSON-COMMON-SYNTAX_OtherContractsMapEntryList_OtherContractsMapEntry_OtherContractsMapEntryList`(`Elt___MICHELSON-COMMON-SYNTAX_OtherContractsMapEntry_String_Type`(A,T),Rs))=>`_Map_`(`_|->_`(inj{Address,KItem}(`#Address(_)_MICHELSON-COMMON_Address_String`(A)),inj{ContractData,KItem}(`#Contract(_,_)_MICHELSON-COMMON_ContractData_Address_Type`(`#Address(_)_MICHELSON-COMMON_Address_String`(A),T))),`#OtherContractsMapEntryListToKMap(_)_MICHELSON-COMMON_Map_OtherContractsMapEntryList`(Rs)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(3e39e9b257be3a4318d0d62093d3c8125b84e69b32711e2f7831ada23805ce39), contentStartColumn(8), contentStartLine(188), org.kframework.attributes.Location(Location(188,8,188,140)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortMap{},R} ( + Lbl'Hash'OtherContractsMapEntryListToKMap'LParUndsRParUnds'MICHELSON-COMMON'Unds'Map'Unds'OtherContractsMapEntryList{}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OtherContractsMapEntryList'Unds'OtherContractsMapEntry'Unds'OtherContractsMapEntryList{}(LblElt'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OtherContractsMapEntry'Unds'String'Unds'Type{}(VarA:SortString{},VarT:SortType{}),VarRs:SortOtherContractsMapEntryList{})), + Lbl'Unds'Map'Unds'{}(Lbl'UndsPipe'-'-GT-Unds'{}(inj{SortAddress{}, SortKItem{}}(Lbl'Hash'Address'LParUndsRParUnds'MICHELSON-COMMON'Unds'Address'Unds'String{}(VarA:SortString{})),inj{SortContractData{}, SortKItem{}}(Lbl'Hash'Contract'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'ContractData'Unds'Address'Unds'Type{}(Lbl'Hash'Address'LParUndsRParUnds'MICHELSON-COMMON'Unds'Address'Unds'String{}(VarA:SortString{}),VarT:SortType{}))),Lbl'Hash'OtherContractsMapEntryListToKMap'LParUndsRParUnds'MICHELSON-COMMON'Unds'Map'Unds'OtherContractsMapEntryList{}(VarRs:SortOtherContractsMapEntryList{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("188"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(188,8,188,140)"), UNIQUE'Unds'ID{}("3e39e9b257be3a4318d0d62093d3c8125b84e69b32711e2f7831ada23805ce39")] + +// rule `#ParseAddress(_)_MICHELSON-COMMON_Address_String`(S)=>`#Address(_)_MICHELSON-COMMON_Address_String`(S) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(27f5e469ca2a19d219107ac6f59494d042612ed049840850bcf091c6ae1929fb), contentStartColumn(8), contentStartLine(245), org.kframework.attributes.Location(Location(245,8,245,39)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortAddress{},R} ( + Lbl'Hash'ParseAddress'LParUndsRParUnds'MICHELSON-COMMON'Unds'Address'Unds'String{}(VarS:SortString{}), + Lbl'Hash'Address'LParUndsRParUnds'MICHELSON-COMMON'Unds'Address'Unds'String{}(VarS:SortString{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("245"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(245,8,245,39)"), UNIQUE'Unds'ID{}("27f5e469ca2a19d219107ac6f59494d042612ed049840850bcf091c6ae1929fb")] + +// rule `#ParseKey(_)_MICHELSON-COMMON_Key_String`(S)=>`#Key(_)_MICHELSON-COMMON_Key_String`(S) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(c2956a3cd478fb44ef27763eada0b7694e098a0ba885308d7170de8f727cfa99), contentStartColumn(8), contentStartLine(248), org.kframework.attributes.Location(Location(248,8,248,31)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortKey{},R} ( + Lbl'Hash'ParseKey'LParUndsRParUnds'MICHELSON-COMMON'Unds'Key'Unds'String{}(VarS:SortString{}), + Lbl'Hash'Key'LParUndsRParUnds'MICHELSON-COMMON'Unds'Key'Unds'String{}(VarS:SortString{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("248"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(248,8,248,31)"), UNIQUE'Unds'ID{}("c2956a3cd478fb44ef27763eada0b7694e098a0ba885308d7170de8f727cfa99")] + +// rule `#ParseKeyHash(_)_MICHELSON-COMMON_KeyHash_String`(S)=>`#KeyHash(_)_MICHELSON-COMMON_KeyHash_String`(S) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(a96b9edf6aded6a2df9c595e1a27040e19e760c38478381ed107eef4200d6626), contentStartColumn(8), contentStartLine(242), org.kframework.attributes.Location(Location(242,8,242,39)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortKeyHash{},R} ( + Lbl'Hash'ParseKeyHash'LParUndsRParUnds'MICHELSON-COMMON'Unds'KeyHash'Unds'String{}(VarS:SortString{}), + Lbl'Hash'KeyHash'LParUndsRParUnds'MICHELSON-COMMON'Unds'KeyHash'Unds'String{}(VarS:SortString{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("242"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(242,8,242,39)"), UNIQUE'Unds'ID{}("a96b9edf6aded6a2df9c595e1a27040e19e760c38478381ed107eef4200d6626")] + +// rule `#ParseSignature(_)_MICHELSON-COMMON_Signature_String`(S)=>`#Signature(_)_MICHELSON-COMMON_Signature_String`(S) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(05fc0b560d29e0620d6841e8e540311f44147cce138914ccf5cac1bf59e3969d), contentStartColumn(8), contentStartLine(251), org.kframework.attributes.Location(Location(251,8,251,43)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortSignature{},R} ( + Lbl'Hash'ParseSignature'LParUndsRParUnds'MICHELSON-COMMON'Unds'Signature'Unds'String{}(VarS:SortString{}), + Lbl'Hash'Signature'LParUndsRParUnds'MICHELSON-COMMON'Unds'Signature'Unds'String{}(VarS:SortString{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("251"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(251,8,251,43)"), UNIQUE'Unds'ID{}("05fc0b560d29e0620d6841e8e540311f44147cce138914ccf5cac1bf59e3969d")] + +// rule `#ParseTimestamp(_)_MICHELSON-COMMON_Timestamp_String`(S)=>`#Timestamp(_)_MICHELSON-COMMON_Timestamp_Int`(`#ISO2Epoch(_)_MICHELSON-COMMON_Int_String`(S)) requires `_>=Int_`(`findString(_,_,_)_STRING-COMMON_Int_String_String_Int`(S,#token("\"Z\"","String"),#token("0","Int")),#token("0","Int")) ensures #token("true","Bool") [UNIQUE_ID(fb66c09e6ffb77203b092db2486ebd9484986e5ffa3d55d6e34b2ad5bef0cfee), contentStartColumn(8), contentStartLine(234), org.kframework.attributes.Location(Location(234,8,234,94)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol])] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + Lbl'Unds-GT-Eqls'Int'Unds'{}(LblfindString'LParUndsCommUndsCommUndsRParUnds'STRING-COMMON'Unds'Int'Unds'String'Unds'String'Unds'Int{}(VarS:SortString{},\dv{SortString{}}("Z"),\dv{SortInt{}}("0")),\dv{SortInt{}}("0")), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortTimestamp{},R} ( + Lbl'Hash'ParseTimestamp'LParUndsRParUnds'MICHELSON-COMMON'Unds'Timestamp'Unds'String{}(VarS:SortString{}), + Lbl'Hash'Timestamp'LParUndsRParUnds'MICHELSON-COMMON'Unds'Timestamp'Unds'Int{}(Lbl'Hash'ISO2Epoch'LParUndsRParUnds'MICHELSON-COMMON'Unds'Int'Unds'String{}(VarS:SortString{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("234"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(234,8,234,94)"), UNIQUE'Unds'ID{}("fb66c09e6ffb77203b092db2486ebd9484986e5ffa3d55d6e34b2ad5bef0cfee")] + +// rule `#ParseTimestamp(_)_MICHELSON-COMMON_Timestamp_String`(S)=>`#Timestamp(_)_MICHELSON-COMMON_Timestamp_Int`(`String2Int(_)_STRING-COMMON_Int_String`(S)) requires `_`#ReverseListAux(_,_)_MICHELSON_List_List_List`(L,`.List`(.KList)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(3cb57e0f83f1e935b4080d10fdd263434f85e8b1b2d12c9d4d9bb441ac8825f0), contentStartColumn(8), contentStartLine(1654), org.kframework.attributes.Location(Location(1648,8,1648,52)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortList{},R} ( + Lbl'Hash'ReverseList'LParUndsRParUnds'MICHELSON'Unds'List'Unds'List{}(VarL:SortList{}), + Lbl'Hash'ReverseListAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'List'Unds'List'Unds'List{}(VarL:SortList{},Lbl'Stop'List{}())), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1654"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1648,8,1648,52)"), UNIQUE'Unds'ID{}("3cb57e0f83f1e935b4080d10fdd263434f85e8b1b2d12c9d4d9bb441ac8825f0")] + +// rule `#ReverseListAux(_,_)_MICHELSON_List_List_List`(`.List`(.KList),Acc)=>Acc requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(1b582c8d66416a6a3fd841297549b3b6c2a06c83275b36de956704ee2f8d0379), contentStartColumn(8), contentStartLine(1657), org.kframework.attributes.Location(Location(1651,8,1651,42)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortList{},R} ( + Lbl'Hash'ReverseListAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'List'Unds'List'Unds'List{}(Lbl'Stop'List{}(),VarAcc:SortList{}), + VarAcc:SortList{}), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1657"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1651,8,1651,42)"), UNIQUE'Unds'ID{}("1b582c8d66416a6a3fd841297549b3b6c2a06c83275b36de956704ee2f8d0379")] + +// rule `#ReverseListAux(_,_)_MICHELSON_List_List_List`(`_List_`(`ListItem`(L1),Ls),Acc)=>`#ReverseListAux(_,_)_MICHELSON_List_List_List`(Ls,`_List_`(`ListItem`(L1),Acc)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(7feea22bd6925577694948ded6531b45acc92d667eb9f060eea33747680e6dc4), contentStartColumn(8), contentStartLine(1655), org.kframework.attributes.Location(Location(1649,8,1650,45)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortList{},R} ( + Lbl'Hash'ReverseListAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'List'Unds'List'Unds'List{}(Lbl'Unds'List'Unds'{}(LblListItem{}(VarL1:SortKItem{}),VarLs:SortList{}),VarAcc:SortList{}), + Lbl'Hash'ReverseListAux'LParUndsCommUndsRParUnds'MICHELSON'Unds'List'Unds'List'Unds'List{}(VarLs:SortList{},Lbl'Unds'List'Unds'{}(LblListItem{}(VarL1:SortKItem{}),VarAcc:SortList{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1655"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1649,8,1650,45)"), UNIQUE'Unds'ID{}("7feea22bd6925577694948ded6531b45acc92d667eb9f060eea33747680e6dc4")] + +// rule `#SliceBytes(_,_,_)_MICHELSON_OptionData_Bytes_Int_Int`(S,O,L)=>`None_MICHELSON-COMMON-SYNTAX_OptionData`(.KList) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(443bad08a51a731adfa43c57a3b5d7e83bb98a77b9ea7af9cb89056950f6f86d), contentStartColumn(8), contentStartLine(1313), org.kframework.attributes.Location(Location(1307,8,1307,36)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]), owise] + axiom{R} \implies{R} ( + \and{R} ( + \not{R} ( + \or{R} ( + \exists{R} (Var'Unds'3:SortBytes{}, + \exists{R} (Var'Unds'5:SortInt{}, + \exists{R} (Var'Unds'4:SortInt{}, + \and{R} ( + \equals{SortBool{},R}( + Lbl'Unds'andBool'Unds'{}(Lbl'Unds'andBool'Unds'{}(Lbl'Unds'andBool'Unds'{}(Lbl'Unds-GT-Eqls'Int'Unds'{}(Var'Unds'4:SortInt{},\dv{SortInt{}}("0")),Lbl'Unds-GT-Eqls'Int'Unds'{}(Var'Unds'5:SortInt{},\dv{SortInt{}}("0"))),Lbl'Unds-LT-'Int'Unds'{}(Var'Unds'4:SortInt{},LbllengthBytes'LParUndsRParUnds'BYTES-HOOKED'Unds'Int'Unds'Bytes{}(Var'Unds'3:SortBytes{}))),Lbl'Unds-LT-Eqls'Int'Unds'{}(Lbl'UndsPlus'Int'Unds'{}(Var'Unds'4:SortInt{},Var'Unds'5:SortInt{}),LbllengthBytes'LParUndsRParUnds'BYTES-HOOKED'Unds'Int'Unds'Bytes{}(Var'Unds'3:SortBytes{}))), + \dv{SortBool{}}("true")), + \and{R} ( + \ceil{SortBytes{}, R} ( + \and{SortBytes{}} ( + VarS:SortBytes{}, + Var'Unds'3:SortBytes{} + )),\and{R} ( + \ceil{SortInt{}, R} ( + \and{SortInt{}} ( + VarO:SortInt{}, + Var'Unds'4:SortInt{} + )),\and{R} ( + \ceil{SortInt{}, R} ( + \and{SortInt{}} ( + VarL:SortInt{}, + Var'Unds'5:SortInt{} + )), + \top{R} () + ))) + )))), + \bottom{R}() + ) + ), + \top{R}() + ), + \and{R} ( + \equals{SortOptionData{},R} ( + Lbl'Hash'SliceBytes'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'OptionData'Unds'Bytes'Unds'Int'Unds'Int{}(VarS:SortBytes{},VarO:SortInt{},VarL:SortInt{}), + LblNone'Unds'MICHELSON-COMMON-SYNTAX'Unds'OptionData{}()), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1313"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1307,8,1307,36)"), owise{}(), UNIQUE'Unds'ID{}("443bad08a51a731adfa43c57a3b5d7e83bb98a77b9ea7af9cb89056950f6f86d")] + +// rule `#SliceBytes(_,_,_)_MICHELSON_OptionData_Bytes_Int_Int`(S,O,L)=>`Some__MICHELSON-COMMON-SYNTAX_OptionData_Data`(inj{Bytes,Data}(`substrBytes(_,_,_)_BYTES-HOOKED_Bytes_Bytes_Int_Int`(S,O,`_+Int_`(O,L)))) requires `_andBool_`(`_andBool_`(`_andBool_`(`_>=Int_`(O,#token("0","Int")),`_>=Int_`(L,#token("0","Int"))),`_`None_MICHELSON-COMMON-SYNTAX_OptionData`(.KList) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(b705d3b5e895453c543cd76fd2e209527b5ba862e5d523e2397d6ac024fa8208), contentStartColumn(8), contentStartLine(1253), org.kframework.attributes.Location(Location(1247,8,1247,37)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]), owise] + axiom{R} \implies{R} ( + \and{R} ( + \not{R} ( + \or{R} ( + \exists{R} (Var'Unds'2:SortInt{}, + \exists{R} (Var'Unds'1:SortInt{}, + \exists{R} (Var'Unds'0:SortString{}, + \and{R} ( + \equals{SortBool{},R}( + Lbl'Unds'andBool'Unds'{}(Lbl'Unds'andBool'Unds'{}(Lbl'Unds'andBool'Unds'{}(Lbl'Unds-GT-Eqls'Int'Unds'{}(Var'Unds'1:SortInt{},\dv{SortInt{}}("0")),Lbl'Unds-GT-Eqls'Int'Unds'{}(Var'Unds'2:SortInt{},\dv{SortInt{}}("0"))),Lbl'Unds-LT-'Int'Unds'{}(Var'Unds'1:SortInt{},LbllengthString'LParUndsRParUnds'STRING-COMMON'Unds'Int'Unds'String{}(Var'Unds'0:SortString{}))),Lbl'Unds-LT-Eqls'Int'Unds'{}(Lbl'UndsPlus'Int'Unds'{}(Var'Unds'1:SortInt{},Var'Unds'2:SortInt{}),LbllengthString'LParUndsRParUnds'STRING-COMMON'Unds'Int'Unds'String{}(Var'Unds'0:SortString{}))), + \dv{SortBool{}}("true")), + \and{R} ( + \ceil{SortString{}, R} ( + \and{SortString{}} ( + VarS:SortString{}, + Var'Unds'0:SortString{} + )),\and{R} ( + \ceil{SortInt{}, R} ( + \and{SortInt{}} ( + VarO:SortInt{}, + Var'Unds'1:SortInt{} + )),\and{R} ( + \ceil{SortInt{}, R} ( + \and{SortInt{}} ( + VarL:SortInt{}, + Var'Unds'2:SortInt{} + )), + \top{R} () + ))) + )))), + \bottom{R}() + ) + ), + \top{R}() + ), + \and{R} ( + \equals{SortOptionData{},R} ( + Lbl'Hash'SliceString'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'OptionData'Unds'String'Unds'Int'Unds'Int{}(VarS:SortString{},VarO:SortInt{},VarL:SortInt{}), + LblNone'Unds'MICHELSON-COMMON-SYNTAX'Unds'OptionData{}()), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1253"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1247,8,1247,37)"), owise{}(), UNIQUE'Unds'ID{}("b705d3b5e895453c543cd76fd2e209527b5ba862e5d523e2397d6ac024fa8208")] + +// rule `#SliceString(_,_,_)_MICHELSON_OptionData_String_Int_Int`(S,O,L)=>`Some__MICHELSON-COMMON-SYNTAX_OptionData_Data`(inj{String,Data}(`substrString(_,_,_)_STRING-COMMON_String_String_Int_Int`(S,O,`_+Int_`(O,L)))) requires `_andBool_`(`_andBool_`(`_andBool_`(`_>=Int_`(O,#token("0","Int")),`_>=Int_`(L,#token("0","Int"))),`_inj{FailedStack,InternalStack}(FS) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(4bbd531c5e2efb5c5402ea5c973f17d4d5eda5817d92e2e8fc1d7e18eeff60a5), contentStartColumn(8), contentStartLine(586), org.kframework.attributes.Location(Location(586,8,586,52)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortInternalStack{},R} ( + Lbl'Hash'StackToNative'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'InternalStack'Unds'OutputStack'Unds'Map'Unds'Map{}(inj{SortFailedStack{}, SortOutputStack{}}(VarFS:SortFailedStack{}),Var'Unds'0:SortMap{},Var'Unds'1:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortFailedStack{}, SortInternalStack{}}(VarFS:SortFailedStack{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("586"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(586,8,586,52)"), UNIQUE'Unds'ID{}("4bbd531c5e2efb5c5402ea5c973f17d4d5eda5817d92e2e8fc1d7e18eeff60a5")] + +// rule `#StackToNative(_,_,_)_MICHELSON_InternalStack_OutputStack_Map_Map`(inj{LiteralStack,OutputStack}(`{_}_UNIT-TEST-COMMON-SYNTAX_LiteralStack_StackElementList`(Ls)),Addrs,BigMaps,#Configuration)=>inj{Stack,InternalStack}(`#StackToNativeAux(_,_,_)_MICHELSON_Stack_StackElementList_Map_Map`(Ls,Addrs,BigMaps,#Configuration)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(6f275c9a2cb1294fd7f2da1a56b92a21c3416226c91f8c69b8899c87121561d9), contentStartColumn(8), contentStartLine(584), org.kframework.attributes.Location(Location(584,8,585,47)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortInternalStack{},R} ( + Lbl'Hash'StackToNative'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'InternalStack'Unds'OutputStack'Unds'Map'Unds'Map{}(inj{SortLiteralStack{}, SortOutputStack{}}(Lbl'LBraUndsRBraUnds'UNIT-TEST-COMMON-SYNTAX'Unds'LiteralStack'Unds'StackElementList{}(VarLs:SortStackElementList{})),VarAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + inj{SortStack{}, SortInternalStack{}}(Lbl'Hash'StackToNativeAux'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Stack'Unds'StackElementList'Unds'Map'Unds'Map{}(VarLs:SortStackElementList{},VarAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("584"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(584,8,585,47)"), UNIQUE'Unds'ID{}("6f275c9a2cb1294fd7f2da1a56b92a21c3416226c91f8c69b8899c87121561d9")] + +// rule `#StackToNativeAux(_,_,_)_MICHELSON_Stack_StackElementList_Map_Map`(`.List{"_;__UNIT-TEST-COMMON-SYNTAX_StackElementList_StackElementLiteral_StackElementList"}_StackElementList`(.KList),_Addrs,_BigMaps,#Configuration)=>`.List{"_;__MICHELSON-COMMON_Stack_StackElement_Stack"}_Stack`(.KList) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(3f5f1350fdfa8981405d9e7f3f4f3b53fc35104686358758ece003c683fb1ba2), contentStartColumn(8), contentStartLine(588), org.kframework.attributes.Location(Location(588,8,588,72)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortStack{},R} ( + Lbl'Hash'StackToNativeAux'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Stack'Unds'StackElementList'Unds'Map'Unds'Map{}(Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'StackElementList'Unds'StackElementLiteral'Unds'StackElementList'QuotRBraUnds'StackElementList{}(),Var'Unds'Addrs:SortMap{},Var'Unds'BigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack'QuotRBraUnds'Stack{}()), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("588"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(588,8,588,72)"), UNIQUE'Unds'ID{}("3f5f1350fdfa8981405d9e7f3f4f3b53fc35104686358758ece003c683fb1ba2")] + +// rule `#StackToNativeAux(_,_,_)_MICHELSON_Stack_StackElementList_Map_Map`(`_;__UNIT-TEST-COMMON-SYNTAX_StackElementList_StackElementLiteral_StackElementList`(`Stack_elt___UNIT-TEST-COMMON-SYNTAX_StackElementLiteral_Type_Data`(T,D),Gs),Addrs,BigMaps,#Configuration)=>`_;__MICHELSON-COMMON_Stack_StackElement_Stack`(`[__]_MICHELSON-COMMON_StackElement_TypeName_Data`(`#Name(_)_MICHELSON-COMMON_TypeName_Type`(T),`#MichelineToNative(_,_,_,_)_MICHELSON-COMMON_Data_DataOrSeq_Type_Map_Map`(inj{Data,DataOrSeq}(D),T,Addrs,BigMaps,#Configuration)),`#StackToNativeAux(_,_,_)_MICHELSON_Stack_StackElementList_Map_Map`(Gs,Addrs,BigMaps,#Configuration)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(938f7ac92bb9848556f3be5cc4ef1f6a23f89119a50d9419afc90196f1a752de), contentStartColumn(8), contentStartLine(589), org.kframework.attributes.Location(Location(589,8,591,45)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortStack{},R} ( + Lbl'Hash'StackToNativeAux'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Stack'Unds'StackElementList'Unds'Map'Unds'Map{}(Lbl'UndsSClnUndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'StackElementList'Unds'StackElementLiteral'Unds'StackElementList{}(LblStack'Unds'elt'UndsUndsUnds'UNIT-TEST-COMMON-SYNTAX'Unds'StackElementLiteral'Unds'Type'Unds'Data{}(VarT:SortType{},VarD:SortData{}),VarGs:SortStackElementList{}),VarAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}), + Lbl'UndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack{}(Lbl'LSqBUndsUndsRSqBUnds'MICHELSON-COMMON'Unds'StackElement'Unds'TypeName'Unds'Data{}(Lbl'Hash'Name'LParUndsRParUnds'MICHELSON-COMMON'Unds'TypeName'Unds'Type{}(VarT:SortType{}),Lbl'Hash'MichelineToNative'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'Data'Unds'DataOrSeq'Unds'Type'Unds'Map'Unds'Map{}(inj{SortData{}, SortDataOrSeq{}}(VarD:SortData{}),VarT:SortType{},VarAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{})),Lbl'Hash'StackToNativeAux'LParUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'Stack'Unds'StackElementList'Unds'Map'Unds'Map{}(VarGs:SortStackElementList{},VarAddrs:SortMap{},VarBigMaps:SortMap{},Var'Hash'Configuration:SortGeneratedTopCell{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("589"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(589,8,591,45)"), UNIQUE'Unds'ID{}("938f7ac92bb9848556f3be5cc4ef1f6a23f89119a50d9419afc90196f1a752de")] + +// rule `#StorageTypeFromContract(_)_MICHELSON-COMMON_Type_Contract`(`_;_;_;_MICHELSON-COMMON-SYNTAX_Contract_CodeDecl_StorageDecl_ParameterDecl`(`code__MICHELSON-COMMON-SYNTAX_CodeDecl_Block`(_0),`storage__MICHELSON-COMMON-SYNTAX_StorageDecl_Type`(S),`parameter__MICHELSON-COMMON-SYNTAX_ParameterDecl_Type`(_1)))=>S requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(ea1a90413d7f6401c7221842745a63a37156dff7cbffb5966361f40ef2113261), contentStartColumn(8), contentStartLine(411), org.kframework.attributes.Location(Location(411,8,411,73)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortType{},R} ( + Lbl'Hash'StorageTypeFromContract'LParUndsRParUnds'MICHELSON-COMMON'Unds'Type'Unds'Contract{}(Lbl'UndsSClnUndsSClnUndsSClnUnds'MICHELSON-COMMON-SYNTAX'Unds'Contract'Unds'CodeDecl'Unds'StorageDecl'Unds'ParameterDecl{}(Lblcode'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'CodeDecl'Unds'Block{}(Var'Unds'0:SortBlock{}),Lblstorage'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'StorageDecl'Unds'Type{}(VarS:SortType{}),Lblparameter'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'ParameterDecl'Unds'Type{}(Var'Unds'1:SortType{}))), + VarS:SortType{}), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("411"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(411,8,411,73)"), UNIQUE'Unds'ID{}("ea1a90413d7f6401c7221842745a63a37156dff7cbffb5966361f40ef2113261")] + +// rule `#Type(_)_MICHELSON-COMMON_Type_TypeName`(`___MICHELSON-COMMON_TypeName_UnaryTypeName_TypeName`(T,ArgT))=>`____MICHELSON-COMMON-SYNTAX_Type_UnaryTypeName_AnnotationList_Type`(T,`.List{"___MICHELSON-COMMON-SYNTAX_AnnotationList_Annotation_AnnotationList"}_AnnotationList`(.KList),`#Type(_)_MICHELSON-COMMON_Type_TypeName`(ArgT)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(c6e446fbd2dbcb851a2afc3b500091ca58b44e40eef3b7aa6c3fcbc529fe6e4c), contentStartColumn(8), contentStartLine(31), org.kframework.attributes.Location(Location(31,8,31,68)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortType{},R} ( + Lbl'Hash'Type'LParUndsRParUnds'MICHELSON-COMMON'Unds'Type'Unds'TypeName{}(Lbl'UndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'UnaryTypeName'Unds'TypeName{}(VarT:SortUnaryTypeName{},VarArgT:SortTypeName{})), + Lbl'UndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'UnaryTypeName'Unds'AnnotationList'Unds'Type{}(VarT:SortUnaryTypeName{},Lbl'Stop'List'LBraQuotUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList'QuotRBraUnds'AnnotationList{}(),Lbl'Hash'Type'LParUndsRParUnds'MICHELSON-COMMON'Unds'Type'Unds'TypeName{}(VarArgT:SortTypeName{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("31"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(31,8,31,68)"), UNIQUE'Unds'ID{}("c6e446fbd2dbcb851a2afc3b500091ca58b44e40eef3b7aa6c3fcbc529fe6e4c")] + +// rule `#Type(_)_MICHELSON-COMMON_Type_TypeName`(`____MICHELSON-COMMON_TypeName_BinaryTypeName_TypeName_TypeName`(T,ArgT1,ArgT2))=>`_____MICHELSON-COMMON-SYNTAX_Type_BinaryTypeName_AnnotationList_Type_Type`(T,`.List{"___MICHELSON-COMMON-SYNTAX_AnnotationList_Annotation_AnnotationList"}_AnnotationList`(.KList),`#Type(_)_MICHELSON-COMMON_Type_TypeName`(ArgT1),`#Type(_)_MICHELSON-COMMON_Type_TypeName`(ArgT2)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(4dc88f4350bd88055799487bd52df801fa4dcbda9d6477b8c7a88d34ad9462a4), contentStartColumn(8), contentStartLine(32), org.kframework.attributes.Location(Location(32,8,32,90)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortType{},R} ( + Lbl'Hash'Type'LParUndsRParUnds'MICHELSON-COMMON'Unds'Type'Unds'TypeName{}(Lbl'UndsUndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'BinaryTypeName'Unds'TypeName'Unds'TypeName{}(VarT:SortBinaryTypeName{},VarArgT1:SortTypeName{},VarArgT2:SortTypeName{})), + Lbl'UndsUndsUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'BinaryTypeName'Unds'AnnotationList'Unds'Type'Unds'Type{}(VarT:SortBinaryTypeName{},Lbl'Stop'List'LBraQuotUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList'QuotRBraUnds'AnnotationList{}(),Lbl'Hash'Type'LParUndsRParUnds'MICHELSON-COMMON'Unds'Type'Unds'TypeName{}(VarArgT1:SortTypeName{}),Lbl'Hash'Type'LParUndsRParUnds'MICHELSON-COMMON'Unds'Type'Unds'TypeName{}(VarArgT2:SortTypeName{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("32"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(32,8,32,90)"), UNIQUE'Unds'ID{}("4dc88f4350bd88055799487bd52df801fa4dcbda9d6477b8c7a88d34ad9462a4")] + +// rule `#Type(_)_MICHELSON-COMMON_Type_TypeName`(inj{NullaryTypeName,TypeName}(T))=>`___MICHELSON-COMMON-SYNTAX_Type_NullaryTypeName_AnnotationList`(T,`.List{"___MICHELSON-COMMON-SYNTAX_AnnotationList_Annotation_AnnotationList"}_AnnotationList`(.KList)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(85f820b64699f17362bb2c4498e0b427ae84d8d1abf1fdb30a48d558d9912942), contentStartColumn(8), contentStartLine(30), org.kframework.attributes.Location(Location(30,8,30,53)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortType{},R} ( + Lbl'Hash'Type'LParUndsRParUnds'MICHELSON-COMMON'Unds'Type'Unds'TypeName{}(inj{SortNullaryTypeName{}, SortTypeName{}}(VarT:SortNullaryTypeName{})), + Lbl'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Type'Unds'NullaryTypeName'Unds'AnnotationList{}(VarT:SortNullaryTypeName{},Lbl'Stop'List'LBraQuotUndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'AnnotationList'Unds'Annotation'Unds'AnnotationList'QuotRBraUnds'AnnotationList{}())), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("30"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(30,8,30,53)"), UNIQUE'Unds'ID{}("85f820b64699f17362bb2c4498e0b427ae84d8d1abf1fdb30a48d558d9912942")] + +// rule `#TypeFromContractStruct(_)_MICHELSON_Type_Data`(inj{ContractData,Data}(`#Contract(_,_)_MICHELSON-COMMON_ContractData_Address_Type`(_0,T)))=>T requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(a0711ca341c0f6296a7e15957b72ed23b0cbba597ae7d26317e5bb5165c41421), contentStartColumn(8), contentStartLine(1737), org.kframework.attributes.Location(Location(1731,8,1731,53)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortType{},R} ( + Lbl'Hash'TypeFromContractStruct'LParUndsRParUnds'MICHELSON'Unds'Type'Unds'Data{}(inj{SortContractData{}, SortData{}}(Lbl'Hash'Contract'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'ContractData'Unds'Address'Unds'Type{}(Var'Unds'0:SortAddress{},VarT:SortType{}))), + VarT:SortType{}), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1737"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1731,8,1731,53)"), UNIQUE'Unds'ID{}("a0711ca341c0f6296a7e15957b72ed23b0cbba597ae7d26317e5bb5165c41421")] + +// rule `#TypeFromOtherContract(_)_MICHELSON-COMMON_Type_ContractData`(`#Contract(_,_)_MICHELSON-COMMON_ContractData_Address_Type`(_0,T))=>T requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(cd88b2c2ac36944fa649c8a9dddb000c7ee3fb853add384ba382fbb66b6d27af), contentStartColumn(8), contentStartLine(423), org.kframework.attributes.Location(Location(423,8,423,52)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/common.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortType{},R} ( + Lbl'Hash'TypeFromOtherContract'LParUndsRParUnds'MICHELSON-COMMON'Unds'Type'Unds'ContractData{}(Lbl'Hash'Contract'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'ContractData'Unds'Address'Unds'Type{}(Var'Unds'0:SortAddress{},VarT:SortType{})), + VarT:SortType{}), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/common.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("423"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(423,8,423,52)"), UNIQUE'Unds'ID{}("cd88b2c2ac36944fa649c8a9dddb000c7ee3fb853add384ba382fbb66b6d27af")] + +// rule `#UnifiedSetToList(_)_MICHELSON_UnifiedList_UnifiedSet`(inj{UnificationFailure,UnifiedSet}(`#UnificationFailure_MICHELSON_UnificationFailure`(.KList) #as _1))=>inj{UnificationFailure,UnifiedList}(_1) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(20051b3df2722b28e4ccaae4dd7b248953d7564bd0b2555afa125a76c4d9d701), contentStartColumn(8), contentStartLine(2236), org.kframework.attributes.Location(Location(2230,8,2230,69)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortUnifiedList{},R} ( + Lbl'Hash'UnifiedSetToList'LParUndsRParUnds'MICHELSON'Unds'UnifiedList'Unds'UnifiedSet{}(inj{SortUnificationFailure{}, SortUnifiedSet{}}(\and{SortUnificationFailure{}}(Lbl'Hash'UnificationFailure'Unds'MICHELSON'Unds'UnificationFailure{}(),Var'Unds'1:SortUnificationFailure{}))), + inj{SortUnificationFailure{}, SortUnifiedList{}}(Var'Unds'1:SortUnificationFailure{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2236"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2230,8,2230,69)"), UNIQUE'Unds'ID{}("20051b3df2722b28e4ccaae4dd7b248953d7564bd0b2555afa125a76c4d9d701")] + +// rule `#UnifiedSetToList(_)_MICHELSON_UnifiedList_UnifiedSet`(inj{Set,UnifiedSet}(S))=>inj{List,UnifiedList}(`Set2List(_)_COLLECTIONS_List_Set`(S)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(8b1cb30ead2228a95035444b4ab24100c34c330ea34bad93b6a29a5b6fd6b699), contentStartColumn(8), contentStartLine(2235), org.kframework.attributes.Location(Location(2229,8,2229,47)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortUnifiedList{},R} ( + Lbl'Hash'UnifiedSetToList'LParUndsRParUnds'MICHELSON'Unds'UnifiedList'Unds'UnifiedSet{}(inj{SortSet{}, SortUnifiedSet{}}(VarS:SortSet{})), + inj{SortList{}, SortUnifiedList{}}(LblSet2List'LParUndsRParUnds'COLLECTIONS'Unds'List'Unds'Set{}(VarS:SortSet{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2235"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2229,8,2229,47)"), UNIQUE'Unds'ID{}("8b1cb30ead2228a95035444b4ab24100c34c330ea34bad93b6a29a5b6fd6b699")] + +// rule `#UnifyTypes(_)_MICHELSON_UnifiedSet_Set`(S)=>inj{Set,UnifiedSet}(S) requires `#AllTypesKnown(_)_MICHELSON_Bool_Set`(S) ensures #token("true","Bool") [UNIQUE_ID(622b010d160ab54499bdfb6742f004317479a57416a01ea83015165b6f4f10ae), contentStartColumn(8), contentStartLine(2226), org.kframework.attributes.Location(Location(2220,8,2221,31)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol]), owise] + axiom{R} \implies{R} ( + \and{R} ( + \not{R} ( + \or{R} ( + \exists{R} (Var'Unds'2:SortSymbolicData{}, + \exists{R} (Var'Unds'3:SortType{}, + \exists{R} (Var'Unds'5:SortSet{}, + \exists{R} (Var'Unds'4:SortType{}, + \and{R} ( + \equals{SortBool{},R}( + Lbl'Unds'andBool'Unds'{}(Lbl'Unds'andBool'Unds'{}(Lbl'UndsEqlsSlshEqls'K'Unds'{}(kseq{}(inj{SortType{}, SortKItem{}}(Var'Unds'3:SortType{}),dotk{}()),kseq{}(inj{SortType{}, SortKItem{}}(Var'Unds'4:SortType{}),dotk{}())),Lbl'UndsEqlsSlshEqls'K'Unds'{}(kseq{}(inj{SortType{}, SortKItem{}}(Var'Unds'3:SortType{}),dotk{}()),kseq{}(inj{SortType{}, SortKItem{}}(Lbl'Hash'UnknownType'Unds'MICHELSON'Unds'Type{}()),dotk{}()))),Lbl'UndsEqlsSlshEqls'K'Unds'{}(kseq{}(inj{SortType{}, SortKItem{}}(Var'Unds'4:SortType{}),dotk{}()),kseq{}(inj{SortType{}, SortKItem{}}(Lbl'Hash'UnknownType'Unds'MICHELSON'Unds'Type{}()),dotk{}()))), + \dv{SortBool{}}("true")), + \and{R} ( + \ceil{SortSet{}, R} ( + \and{SortSet{}} ( + VarS:SortSet{}, + Lbl'Unds'Set'Unds'{}(Lbl'Unds'Set'Unds'{}(LblSetItem{}(inj{SortSymbolicElement{}, SortKItem{}}(Lbl'Hash'SymbolicElement'LParUndsCommUndsRParUnds'MICHELSON'Unds'SymbolicElement'Unds'SymbolicData'Unds'Type{}(Var'Unds'2:SortSymbolicData{},Var'Unds'3:SortType{}))),LblSetItem{}(inj{SortSymbolicElement{}, SortKItem{}}(Lbl'Hash'SymbolicElement'LParUndsCommUndsRParUnds'MICHELSON'Unds'SymbolicElement'Unds'SymbolicData'Unds'Type{}(Var'Unds'2:SortSymbolicData{},Var'Unds'4:SortType{})))),Var'Unds'5:SortSet{}) + )), + \top{R} () + ) + ))))), + \or{R} ( + \exists{R} (Var'Unds'8:SortSet{}, + \exists{R} (Var'Unds'6:SortSymbolicData{}, + \exists{R} (Var'Unds'7:SortType{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortSet{}, R} ( + \and{SortSet{}} ( + VarS:SortSet{}, + Lbl'Unds'Set'Unds'{}(Lbl'Unds'Set'Unds'{}(LblSetItem{}(inj{SortSymbolicElement{}, SortKItem{}}(Lbl'Hash'SymbolicElement'LParUndsCommUndsRParUnds'MICHELSON'Unds'SymbolicElement'Unds'SymbolicData'Unds'Type{}(Var'Unds'6:SortSymbolicData{},Lbl'Hash'UnknownType'Unds'MICHELSON'Unds'Type{}()))),LblSetItem{}(inj{SortSymbolicElement{}, SortKItem{}}(Lbl'Hash'SymbolicElement'LParUndsCommUndsRParUnds'MICHELSON'Unds'SymbolicElement'Unds'SymbolicData'Unds'Type{}(Var'Unds'6:SortSymbolicData{},Var'Unds'7:SortType{})))),Var'Unds'8:SortSet{}) + )), + \top{R} () + ) + )))), + \bottom{R}() + )) + ), + \equals{SortBool{},R}( + Lbl'Hash'AllTypesKnown'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'Set{}(VarS:SortSet{}), + \dv{SortBool{}}("true")) + ), + \and{R} ( + \equals{SortUnifiedSet{},R} ( + Lbl'Hash'UnifyTypes'LParUndsRParUnds'MICHELSON'Unds'UnifiedSet'Unds'Set{}(VarS:SortSet{}), + inj{SortSet{}, SortUnifiedSet{}}(VarS:SortSet{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("2226"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2220,8,2221,31)"), owise{}(), UNIQUE'Unds'ID{}("622b010d160ab54499bdfb6742f004317479a57416a01ea83015165b6f4f10ae")] + +// rule `#UnifyTypes(_)_MICHELSON_UnifiedSet_Set`(S)=>inj{UnificationFailure,UnifiedSet}(`#UnificationFailure_MICHELSON_UnificationFailure`(.KList)) requires `notBool_`(`#AllTypesKnown(_)_MICHELSON_Bool_Set`(S)) ensures #token("true","Bool") [UNIQUE_ID(282d03b365da1656781e8073921c102d8a2e4ba53e40a17230d5003505017775), contentStartColumn(8), contentStartLine(2229), org.kframework.attributes.Location(Location(2223,8,2224,40)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol]), owise] + axiom{R} \implies{R} ( + \and{R} ( + \not{R} ( + \or{R} ( + \exists{R} (Var'Unds'2:SortSymbolicData{}, + \exists{R} (Var'Unds'3:SortType{}, + \exists{R} (Var'Unds'5:SortSet{}, + \exists{R} (Var'Unds'4:SortType{}, + \and{R} ( + \equals{SortBool{},R}( + Lbl'Unds'andBool'Unds'{}(Lbl'Unds'andBool'Unds'{}(Lbl'UndsEqlsSlshEqls'K'Unds'{}(kseq{}(inj{SortType{}, SortKItem{}}(Var'Unds'3:SortType{}),dotk{}()),kseq{}(inj{SortType{}, SortKItem{}}(Var'Unds'4:SortType{}),dotk{}())),Lbl'UndsEqlsSlshEqls'K'Unds'{}(kseq{}(inj{SortType{}, SortKItem{}}(Var'Unds'3:SortType{}),dotk{}()),kseq{}(inj{SortType{}, SortKItem{}}(Lbl'Hash'UnknownType'Unds'MICHELSON'Unds'Type{}()),dotk{}()))),Lbl'UndsEqlsSlshEqls'K'Unds'{}(kseq{}(inj{SortType{}, SortKItem{}}(Var'Unds'4:SortType{}),dotk{}()),kseq{}(inj{SortType{}, SortKItem{}}(Lbl'Hash'UnknownType'Unds'MICHELSON'Unds'Type{}()),dotk{}()))), + \dv{SortBool{}}("true")), + \and{R} ( + \ceil{SortSet{}, R} ( + \and{SortSet{}} ( + VarS:SortSet{}, + Lbl'Unds'Set'Unds'{}(Lbl'Unds'Set'Unds'{}(LblSetItem{}(inj{SortSymbolicElement{}, SortKItem{}}(Lbl'Hash'SymbolicElement'LParUndsCommUndsRParUnds'MICHELSON'Unds'SymbolicElement'Unds'SymbolicData'Unds'Type{}(Var'Unds'2:SortSymbolicData{},Var'Unds'3:SortType{}))),LblSetItem{}(inj{SortSymbolicElement{}, SortKItem{}}(Lbl'Hash'SymbolicElement'LParUndsCommUndsRParUnds'MICHELSON'Unds'SymbolicElement'Unds'SymbolicData'Unds'Type{}(Var'Unds'2:SortSymbolicData{},Var'Unds'4:SortType{})))),Var'Unds'5:SortSet{}) + )), + \top{R} () + ) + ))))), + \or{R} ( + \exists{R} (Var'Unds'8:SortSet{}, + \exists{R} (Var'Unds'6:SortSymbolicData{}, + \exists{R} (Var'Unds'7:SortType{}, + \and{R} ( + \top{R}(), + \and{R} ( + \ceil{SortSet{}, R} ( + \and{SortSet{}} ( + VarS:SortSet{}, + Lbl'Unds'Set'Unds'{}(Lbl'Unds'Set'Unds'{}(LblSetItem{}(inj{SortSymbolicElement{}, SortKItem{}}(Lbl'Hash'SymbolicElement'LParUndsCommUndsRParUnds'MICHELSON'Unds'SymbolicElement'Unds'SymbolicData'Unds'Type{}(Var'Unds'6:SortSymbolicData{},Lbl'Hash'UnknownType'Unds'MICHELSON'Unds'Type{}()))),LblSetItem{}(inj{SortSymbolicElement{}, SortKItem{}}(Lbl'Hash'SymbolicElement'LParUndsCommUndsRParUnds'MICHELSON'Unds'SymbolicElement'Unds'SymbolicData'Unds'Type{}(Var'Unds'6:SortSymbolicData{},Var'Unds'7:SortType{})))),Var'Unds'8:SortSet{}) + )), + \top{R} () + ) + )))), + \bottom{R}() + )) + ), + \equals{SortBool{},R}( + LblnotBool'Unds'{}(Lbl'Hash'AllTypesKnown'LParUndsRParUnds'MICHELSON'Unds'Bool'Unds'Set{}(VarS:SortSet{})), + \dv{SortBool{}}("true")) + ), + \and{R} ( + \equals{SortUnifiedSet{},R} ( + Lbl'Hash'UnifyTypes'LParUndsRParUnds'MICHELSON'Unds'UnifiedSet'Unds'Set{}(VarS:SortSet{}), + inj{SortUnificationFailure{}, SortUnifiedSet{}}(Lbl'Hash'UnificationFailure'Unds'MICHELSON'Unds'UnificationFailure{}())), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("2229"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2223,8,2224,40)"), owise{}(), UNIQUE'Unds'ID{}("282d03b365da1656781e8073921c102d8a2e4ba53e40a17230d5003505017775")] + +// rule `#UnifyTypes(_)_MICHELSON_UnifiedSet_Set`(`_Set_`(`_Set_`(`SetItem`(inj{SymbolicElement,KItem}(`#SymbolicElement(_,_)_MICHELSON_SymbolicElement_SymbolicData_Type`(S,T1))),`SetItem`(inj{SymbolicElement,KItem}(`#SymbolicElement(_,_)_MICHELSON_SymbolicElement_SymbolicData_Type`(S,T2)))),_0))=>inj{UnificationFailure,UnifiedSet}(`#UnificationFailure_MICHELSON_UnificationFailure`(.KList)) requires `_andBool_`(`_andBool_`(`_=/=K_`(inj{Type,KItem}(T1),inj{Type,KItem}(T2)),`_=/=K_`(inj{Type,KItem}(T1),inj{Type,KItem}(`#UnknownType_MICHELSON_Type`(.KList)))),`_=/=K_`(inj{Type,KItem}(T2),inj{Type,KItem}(`#UnknownType_MICHELSON_Type`(.KList)))) ensures #token("true","Bool") [UNIQUE_ID(a406faaeb6778e5e85cadde306c3ecbb0b34e5894f2d7569fda18c7e7030f86c), contentStartColumn(8), contentStartLine(2219), org.kframework.attributes.Location(Location(2213,8,2218,34)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol])] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + Lbl'Unds'andBool'Unds'{}(Lbl'Unds'andBool'Unds'{}(Lbl'UndsEqlsSlshEqls'K'Unds'{}(kseq{}(inj{SortType{}, SortKItem{}}(VarT1:SortType{}),dotk{}()),kseq{}(inj{SortType{}, SortKItem{}}(VarT2:SortType{}),dotk{}())),Lbl'UndsEqlsSlshEqls'K'Unds'{}(kseq{}(inj{SortType{}, SortKItem{}}(VarT1:SortType{}),dotk{}()),kseq{}(inj{SortType{}, SortKItem{}}(Lbl'Hash'UnknownType'Unds'MICHELSON'Unds'Type{}()),dotk{}()))),Lbl'UndsEqlsSlshEqls'K'Unds'{}(kseq{}(inj{SortType{}, SortKItem{}}(VarT2:SortType{}),dotk{}()),kseq{}(inj{SortType{}, SortKItem{}}(Lbl'Hash'UnknownType'Unds'MICHELSON'Unds'Type{}()),dotk{}()))), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortUnifiedSet{},R} ( + Lbl'Hash'UnifyTypes'LParUndsRParUnds'MICHELSON'Unds'UnifiedSet'Unds'Set{}(Lbl'Unds'Set'Unds'{}(Lbl'Unds'Set'Unds'{}(LblSetItem{}(inj{SortSymbolicElement{}, SortKItem{}}(Lbl'Hash'SymbolicElement'LParUndsCommUndsRParUnds'MICHELSON'Unds'SymbolicElement'Unds'SymbolicData'Unds'Type{}(VarS:SortSymbolicData{},VarT1:SortType{}))),LblSetItem{}(inj{SortSymbolicElement{}, SortKItem{}}(Lbl'Hash'SymbolicElement'LParUndsCommUndsRParUnds'MICHELSON'Unds'SymbolicElement'Unds'SymbolicData'Unds'Type{}(VarS:SortSymbolicData{},VarT2:SortType{})))),Var'Unds'0:SortSet{})), + inj{SortUnificationFailure{}, SortUnifiedSet{}}(Lbl'Hash'UnificationFailure'Unds'MICHELSON'Unds'UnificationFailure{}())), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("2219"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2213,8,2218,34)"), UNIQUE'Unds'ID{}("a406faaeb6778e5e85cadde306c3ecbb0b34e5894f2d7569fda18c7e7030f86c")] + +// rule `#UnifyTypes(_)_MICHELSON_UnifiedSet_Set`(`_Set_`(`_Set_`(`SetItem`(inj{SymbolicElement,KItem}(`#SymbolicElement(_,_)_MICHELSON_SymbolicElement_SymbolicData_Type`(S,`#UnknownType_MICHELSON_Type`(.KList)))),`SetItem`(inj{SymbolicElement,KItem}(`#SymbolicElement(_,_)_MICHELSON_SymbolicElement_SymbolicData_Type`(S,T)))),Ss))=>`#UnifyTypes(_)_MICHELSON_UnifiedSet_Set`(`_Set_`(`SetItem`(inj{SymbolicElement,KItem}(`#SymbolicElement(_,_)_MICHELSON_SymbolicElement_SymbolicData_Type`(S,T))),Ss)) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(0b375dc99554b93275e6104d4817c8dfb0bc282f6dd613e6d0c948521cf8bbc9), contentStartColumn(8), contentStartLine(2215), org.kframework.attributes.Location(Location(2209,8,2211,55)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortUnifiedSet{},R} ( + Lbl'Hash'UnifyTypes'LParUndsRParUnds'MICHELSON'Unds'UnifiedSet'Unds'Set{}(Lbl'Unds'Set'Unds'{}(Lbl'Unds'Set'Unds'{}(LblSetItem{}(inj{SortSymbolicElement{}, SortKItem{}}(Lbl'Hash'SymbolicElement'LParUndsCommUndsRParUnds'MICHELSON'Unds'SymbolicElement'Unds'SymbolicData'Unds'Type{}(VarS:SortSymbolicData{},Lbl'Hash'UnknownType'Unds'MICHELSON'Unds'Type{}()))),LblSetItem{}(inj{SortSymbolicElement{}, SortKItem{}}(Lbl'Hash'SymbolicElement'LParUndsCommUndsRParUnds'MICHELSON'Unds'SymbolicElement'Unds'SymbolicData'Unds'Type{}(VarS:SortSymbolicData{},VarT:SortType{})))),VarSs:SortSet{})), + Lbl'Hash'UnifyTypes'LParUndsRParUnds'MICHELSON'Unds'UnifiedSet'Unds'Set{}(Lbl'Unds'Set'Unds'{}(LblSetItem{}(inj{SortSymbolicElement{}, SortKItem{}}(Lbl'Hash'SymbolicElement'LParUndsCommUndsRParUnds'MICHELSON'Unds'SymbolicElement'Unds'SymbolicData'Unds'Type{}(VarS:SortSymbolicData{},VarT:SortType{}))),VarSs:SortSet{}))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2215"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2209,8,2211,55)"), UNIQUE'Unds'ID{}("0b375dc99554b93275e6104d4817c8dfb0bc282f6dd613e6d0c948521cf8bbc9")] + +// rule `#if_#then_#else_#fi_K-EQUAL-SYNTAX_Sort_Bool_Sort_Sort`{K}(C,B1,_0)=>B1 requires C ensures #token("true","Bool") [UNIQUE_ID(2b32069ac3f589174502fa507ebc88fab7c902854c0a9baa8ab09beb551232e2), contentStartColumn(8), contentStartLine(1995), org.kframework.attributes.Location(Location(1995,8,1995,59)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol])] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + VarC:SortBool{}, + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortK{},R} ( + Lbl'Hash'if'UndsHash'then'UndsHash'else'UndsHash'fi'Unds'K-EQUAL-SYNTAX'Unds'Sort'Unds'Bool'Unds'Sort'Unds'Sort{SortK{}}(VarC:SortBool{},VarB1:SortK{},Var'Unds'0:SortK{}), + VarB1:SortK{}), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("1995"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1995,8,1995,59)"), UNIQUE'Unds'ID{}("2b32069ac3f589174502fa507ebc88fab7c902854c0a9baa8ab09beb551232e2")] + +// rule `#if_#then_#else_#fi_K-EQUAL-SYNTAX_Sort_Bool_Sort_Sort`{K}(C,_0,B2)=>B2 requires `notBool_`(C) ensures #token("true","Bool") [UNIQUE_ID(651bff3fa53d464ac7dd7aa77e1ef6071e14c959eb6df97baa325e2ad300daaa), contentStartColumn(8), contentStartLine(1996), org.kframework.attributes.Location(Location(1996,8,1996,67)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol])] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + LblnotBool'Unds'{}(VarC:SortBool{}), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortK{},R} ( + Lbl'Hash'if'UndsHash'then'UndsHash'else'UndsHash'fi'Unds'K-EQUAL-SYNTAX'Unds'Sort'Unds'Bool'Unds'Sort'Unds'Sort{SortK{}}(VarC:SortBool{},Var'Unds'0:SortK{},VarB2:SortK{}), + VarB2:SortK{}), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("1996"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1996,8,1996,67)"), UNIQUE'Unds'ID{}("651bff3fa53d464ac7dd7aa77e1ef6071e14c959eb6df97baa325e2ad300daaa")] + +// rule `#lookup(_,_,_,_)_MICHELSON_OptionData_Map_TypeName_SimpleData_TypeName`(M,KT,K,_VT)=>`None_MICHELSON-COMMON-SYNTAX_OptionData`(.KList) requires `_andBool_`(`isValue(_,_)_MICHELSON_Bool_TypeName_Data`(KT,inj{SimpleData,Data}(K)),`notBool_`(`_in_keys(_)_MAP_Bool_KItem_Map`(inj{SimpleData,KItem}(K),M))) ensures #token("true","Bool") [UNIQUE_ID(1902c32baa3f861b3bcec3eed01e4f5772e3b614a32e689e670d5be9f57c2db4), contentStartColumn(8), contentStartLine(1397), org.kframework.attributes.Location(Location(1391,8,1391,111)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol])] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + Lbl'Unds'andBool'Unds'{}(LblisValue'LParUndsCommUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName'Unds'Data{}(VarKT:SortTypeName{},inj{SortSimpleData{}, SortData{}}(VarK:SortSimpleData{})),LblnotBool'Unds'{}(Lbl'Unds'in'Unds'keys'LParUndsRParUnds'MAP'Unds'Bool'Unds'KItem'Unds'Map{}(inj{SortSimpleData{}, SortKItem{}}(VarK:SortSimpleData{}),VarM:SortMap{}))), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortOptionData{},R} ( + Lbl'Hash'lookup'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'OptionData'Unds'Map'Unds'TypeName'Unds'SimpleData'Unds'TypeName{}(VarM:SortMap{},VarKT:SortTypeName{},VarK:SortSimpleData{},Var'Unds'VT:SortTypeName{}), + LblNone'Unds'MICHELSON-COMMON-SYNTAX'Unds'OptionData{}()), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("1397"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1391,8,1391,111)"), UNIQUE'Unds'ID{}("1902c32baa3f861b3bcec3eed01e4f5772e3b614a32e689e670d5be9f57c2db4")] + +// rule `#lookup(_,_,_,_)_MICHELSON_OptionData_Map_TypeName_SimpleData_TypeName`(`Map:update`(M,K1,_V),KT,K2,VT)=>`#lookup(_,_,_,_)_MICHELSON_OptionData_Map_TypeName_SimpleData_TypeName`(M,KT,K2,VT) requires `_=/=K_`(K1,inj{SimpleData,KItem}(K2)) ensures #token("true","Bool") [UNIQUE_ID(c0fe3c41bb8229bdde4af54d492fa92afa0617ae6702ba14bf485eaa6aa614d0), contentStartColumn(18), contentStartLine(1409), label(MICHELSON.simp3), org.kframework.attributes.Location(Location(1403,8,1403,114)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol]), simplification] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + Lbl'UndsEqlsSlshEqls'K'Unds'{}(kseq{}(VarK1:SortKItem{},dotk{}()),kseq{}(inj{SortSimpleData{}, SortKItem{}}(VarK2:SortSimpleData{}),dotk{}())), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortOptionData{},R} ( + Lbl'Hash'lookup'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'OptionData'Unds'Map'Unds'TypeName'Unds'SimpleData'Unds'TypeName{}(LblMap'Coln'update{}(VarM:SortMap{},VarK1:SortKItem{},Var'Unds'V:SortKItem{}),VarKT:SortTypeName{},VarK2:SortSimpleData{},VarVT:SortTypeName{}), + Lbl'Hash'lookup'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'OptionData'Unds'Map'Unds'TypeName'Unds'SimpleData'Unds'TypeName{}(VarM:SortMap{},VarKT:SortTypeName{},VarK2:SortSimpleData{},VarVT:SortTypeName{})), + \top{R}())) + [label{}("MICHELSON.simp3"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("1409"), contentStartColumn{}("18"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1403,8,1403,114)"), simplification{}(), UNIQUE'Unds'ID{}("c0fe3c41bb8229bdde4af54d492fa92afa0617ae6702ba14bf485eaa6aa614d0")] + +// rule `#lookup(_,_,_,_)_MICHELSON_OptionData_Map_TypeName_SimpleData_TypeName`(`Map:update`(M,K1,_V),KT,K2,VT)=>`#lookup(_,_,_,_)_MICHELSON_OptionData_Map_TypeName_SimpleData_TypeName`(M,KT,K2,VT) requires `notBool_`(`_==K_`(K1,inj{SimpleData,KItem}(K2))) ensures #token("true","Bool") [UNIQUE_ID(8331ab20ac162354ffacf0cfe6b96a01f958b92e74b923f395ab4866b1cd2e14), contentStartColumn(18), contentStartLine(1407), label(MICHELSON.simp1), org.kframework.attributes.Location(Location(1401,8,1401,114)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol]), simplification] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + LblnotBool'Unds'{}(Lbl'UndsEqlsEqls'K'Unds'{}(kseq{}(VarK1:SortKItem{},dotk{}()),kseq{}(inj{SortSimpleData{}, SortKItem{}}(VarK2:SortSimpleData{}),dotk{}()))), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortOptionData{},R} ( + Lbl'Hash'lookup'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'OptionData'Unds'Map'Unds'TypeName'Unds'SimpleData'Unds'TypeName{}(LblMap'Coln'update{}(VarM:SortMap{},VarK1:SortKItem{},Var'Unds'V:SortKItem{}),VarKT:SortTypeName{},VarK2:SortSimpleData{},VarVT:SortTypeName{}), + Lbl'Hash'lookup'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'OptionData'Unds'Map'Unds'TypeName'Unds'SimpleData'Unds'TypeName{}(VarM:SortMap{},VarKT:SortTypeName{},VarK2:SortSimpleData{},VarVT:SortTypeName{})), + \top{R}())) + [label{}("MICHELSON.simp1"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("1407"), contentStartColumn{}("18"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1401,8,1401,114)"), simplification{}(), UNIQUE'Unds'ID{}("8331ab20ac162354ffacf0cfe6b96a01f958b92e74b923f395ab4866b1cd2e14")] + +// rule `#lookup(_,_,_,_)_MICHELSON_OptionData_Map_TypeName_SimpleData_TypeName`(`Map:update`(M,K1,inj{Data,KItem}(V)),KT,K2,VT)=>`Some__MICHELSON-COMMON-SYNTAX_OptionData_Data`(V) requires `_==K_`(K1,inj{SimpleData,KItem}(K2)) ensures #token("true","Bool") [UNIQUE_ID(04d353d250fba1f9d81ef7a89659e5b117d84b685546cc67ea4767dbb5e0e414), contentStartColumn(8), contentStartLine(1413), org.kframework.attributes.Location(Location(1407,8,1407,88)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol]), simplification] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + Lbl'UndsEqlsEqls'K'Unds'{}(kseq{}(VarK1:SortKItem{},dotk{}()),kseq{}(inj{SortSimpleData{}, SortKItem{}}(VarK2:SortSimpleData{}),dotk{}())), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortOptionData{},R} ( + Lbl'Hash'lookup'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'OptionData'Unds'Map'Unds'TypeName'Unds'SimpleData'Unds'TypeName{}(LblMap'Coln'update{}(VarM:SortMap{},VarK1:SortKItem{},inj{SortData{}, SortKItem{}}(VarV:SortData{})),VarKT:SortTypeName{},VarK2:SortSimpleData{},VarVT:SortTypeName{}), + LblSome'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OptionData'Unds'Data{}(VarV:SortData{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("1413"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1407,8,1407,88)"), simplification{}(), UNIQUE'Unds'ID{}("04d353d250fba1f9d81ef7a89659e5b117d84b685546cc67ea4767dbb5e0e414")] + +// rule `#lookup(_,_,_,_)_MICHELSON_OptionData_Map_TypeName_SimpleData_TypeName`(`Map:update`(M,inj{Int,KItem}(K1),_V),KT,inj{Int,SimpleData}(K2) #as _2,VT)=>`#lookup(_,_,_,_)_MICHELSON_OptionData_Map_TypeName_SimpleData_TypeName`(M,KT,_2,VT) requires `_=/=Int_`(K1,K2) ensures #token("true","Bool") [UNIQUE_ID(a9eeaf20fe70b6db62e330b9c564d66e053cada1bd56984546821da1d79778f6), contentStartColumn(18), contentStartLine(1410), label(MICHELSON.simp4), org.kframework.attributes.Location(Location(1404,8,1404,114)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol]), simplification] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + Lbl'UndsEqlsSlshEqls'Int'Unds'{}(VarK1:SortInt{},VarK2:SortInt{}), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortOptionData{},R} ( + Lbl'Hash'lookup'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'OptionData'Unds'Map'Unds'TypeName'Unds'SimpleData'Unds'TypeName{}(LblMap'Coln'update{}(VarM:SortMap{},inj{SortInt{}, SortKItem{}}(VarK1:SortInt{}),Var'Unds'V:SortKItem{}),VarKT:SortTypeName{},\and{SortSimpleData{}}(inj{SortInt{}, SortSimpleData{}}(VarK2:SortInt{}),Var'Unds'2:SortSimpleData{}),VarVT:SortTypeName{}), + Lbl'Hash'lookup'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'OptionData'Unds'Map'Unds'TypeName'Unds'SimpleData'Unds'TypeName{}(VarM:SortMap{},VarKT:SortTypeName{},Var'Unds'2:SortSimpleData{},VarVT:SortTypeName{})), + \top{R}())) + [label{}("MICHELSON.simp4"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("1410"), contentStartColumn{}("18"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1404,8,1404,114)"), simplification{}(), UNIQUE'Unds'ID{}("a9eeaf20fe70b6db62e330b9c564d66e053cada1bd56984546821da1d79778f6")] + +// rule `#lookup(_,_,_,_)_MICHELSON_OptionData_Map_TypeName_SimpleData_TypeName`(`Map:update`(M,inj{Int,KItem}(K1),_V),KT,inj{Int,SimpleData}(K2) #as _2,VT)=>`#lookup(_,_,_,_)_MICHELSON_OptionData_Map_TypeName_SimpleData_TypeName`(M,KT,_2,VT) requires `notBool_`(`_==Int_`(K1,K2)) ensures #token("true","Bool") [UNIQUE_ID(93e9f27736eec66844af71d5cf7867653c962ec2e42af82118b4df68f9901184), contentStartColumn(18), contentStartLine(1408), label(MICHELSON.simp2), org.kframework.attributes.Location(Location(1402,8,1402,114)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol]), simplification] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + LblnotBool'Unds'{}(Lbl'UndsEqlsEqls'Int'Unds'{}(VarK1:SortInt{},VarK2:SortInt{})), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortOptionData{},R} ( + Lbl'Hash'lookup'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'OptionData'Unds'Map'Unds'TypeName'Unds'SimpleData'Unds'TypeName{}(LblMap'Coln'update{}(VarM:SortMap{},inj{SortInt{}, SortKItem{}}(VarK1:SortInt{}),Var'Unds'V:SortKItem{}),VarKT:SortTypeName{},\and{SortSimpleData{}}(inj{SortInt{}, SortSimpleData{}}(VarK2:SortInt{}),Var'Unds'2:SortSimpleData{}),VarVT:SortTypeName{}), + Lbl'Hash'lookup'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'OptionData'Unds'Map'Unds'TypeName'Unds'SimpleData'Unds'TypeName{}(VarM:SortMap{},VarKT:SortTypeName{},Var'Unds'2:SortSimpleData{},VarVT:SortTypeName{})), + \top{R}())) + [label{}("MICHELSON.simp2"), org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("1408"), contentStartColumn{}("18"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1402,8,1402,114)"), simplification{}(), UNIQUE'Unds'ID{}("93e9f27736eec66844af71d5cf7867653c962ec2e42af82118b4df68f9901184")] + +// rule `#lookup(_,_,_,_)_MICHELSON_OptionData_Map_TypeName_SimpleData_TypeName`(`Map:update`(M,inj{Int,KItem}(K1),inj{Data,KItem}(V)),KT,inj{Int,SimpleData}(K2),VT)=>`Some__MICHELSON-COMMON-SYNTAX_OptionData_Data`(V) requires `_==Int_`(K1,K2) ensures #token("true","Bool") [UNIQUE_ID(c22fc217a5b8726e270856086ab117c398bfd1b327770daffbdc22770a0e9ae6), contentStartColumn(8), contentStartLine(1414), org.kframework.attributes.Location(Location(1408,8,1408,88)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol]), simplification] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + Lbl'UndsEqlsEqls'Int'Unds'{}(VarK1:SortInt{},VarK2:SortInt{}), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortOptionData{},R} ( + Lbl'Hash'lookup'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'OptionData'Unds'Map'Unds'TypeName'Unds'SimpleData'Unds'TypeName{}(LblMap'Coln'update{}(VarM:SortMap{},inj{SortInt{}, SortKItem{}}(VarK1:SortInt{}),inj{SortData{}, SortKItem{}}(VarV:SortData{})),VarKT:SortTypeName{},inj{SortInt{}, SortSimpleData{}}(VarK2:SortInt{}),VarVT:SortTypeName{}), + LblSome'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OptionData'Unds'Data{}(VarV:SortData{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("1414"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1408,8,1408,88)"), simplification{}(), UNIQUE'Unds'ID{}("c22fc217a5b8726e270856086ab117c398bfd1b327770daffbdc22770a0e9ae6")] + +// rule `#lookup(_,_,_,_)_MICHELSON_OptionData_Map_TypeName_SimpleData_TypeName`(`Map:update`(_M,inj{SimpleData,KItem}(K),inj{Data,KItem}(V)),KT,K,VT)=>`Some__MICHELSON-COMMON-SYNTAX_OptionData_Data`(V) requires `_andBool_`(`isValue(_,_)_MICHELSON_Bool_TypeName_Data`(KT,inj{SimpleData,Data}(K)),`isValue(_,_)_MICHELSON_Bool_TypeName_Data`(VT,V)) ensures #token("true","Bool") [UNIQUE_ID(747512c5d1609b8d15dfeeea56fec46685252d5943973dfbf06a3a618ec06b48), contentStartColumn(8), contentStartLine(1404), org.kframework.attributes.Location(Location(1398,8,1398,108)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol]), simplification] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + Lbl'Unds'andBool'Unds'{}(LblisValue'LParUndsCommUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName'Unds'Data{}(VarKT:SortTypeName{},inj{SortSimpleData{}, SortData{}}(VarK:SortSimpleData{})),LblisValue'LParUndsCommUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName'Unds'Data{}(VarVT:SortTypeName{},VarV:SortData{})), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortOptionData{},R} ( + Lbl'Hash'lookup'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'OptionData'Unds'Map'Unds'TypeName'Unds'SimpleData'Unds'TypeName{}(LblMap'Coln'update{}(Var'Unds'M:SortMap{},inj{SortSimpleData{}, SortKItem{}}(VarK:SortSimpleData{}),inj{SortData{}, SortKItem{}}(VarV:SortData{})),VarKT:SortTypeName{},VarK:SortSimpleData{},VarVT:SortTypeName{}), + LblSome'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OptionData'Unds'Data{}(VarV:SortData{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("1404"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1398,8,1398,108)"), simplification{}(), UNIQUE'Unds'ID{}("747512c5d1609b8d15dfeeea56fec46685252d5943973dfbf06a3a618ec06b48")] + +// rule `#lookup(_,_,_,_)_MICHELSON_OptionData_Map_TypeName_SimpleData_TypeName`(`_Map_`(`_|->_`(inj{SimpleData,KItem}(K),inj{Data,KItem}(V)),_M),KT,K,VT)=>`Some__MICHELSON-COMMON-SYNTAX_OptionData_Data`(V) requires `_andBool_`(`isValue(_,_)_MICHELSON_Bool_TypeName_Data`(KT,inj{SimpleData,Data}(K)),`isValue(_,_)_MICHELSON_Bool_TypeName_Data`(VT,V)) ensures #token("true","Bool") [UNIQUE_ID(aa42337769dde4931feb212ffab11db05be4243c71f23aab2fb44236ca261eeb), contentStartColumn(8), contentStartLine(1396), org.kframework.attributes.Location(Location(1390,8,1390,103)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol])] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + Lbl'Unds'andBool'Unds'{}(LblisValue'LParUndsCommUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName'Unds'Data{}(VarKT:SortTypeName{},inj{SortSimpleData{}, SortData{}}(VarK:SortSimpleData{})),LblisValue'LParUndsCommUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName'Unds'Data{}(VarVT:SortTypeName{},VarV:SortData{})), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortOptionData{},R} ( + Lbl'Hash'lookup'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'OptionData'Unds'Map'Unds'TypeName'Unds'SimpleData'Unds'TypeName{}(Lbl'Unds'Map'Unds'{}(Lbl'UndsPipe'-'-GT-Unds'{}(inj{SortSimpleData{}, SortKItem{}}(VarK:SortSimpleData{}),inj{SortData{}, SortKItem{}}(VarV:SortData{})),Var'Unds'M:SortMap{}),VarKT:SortTypeName{},VarK:SortSimpleData{},VarVT:SortTypeName{}), + LblSome'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'OptionData'Unds'Data{}(VarV:SortData{})), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("1396"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1390,8,1390,103)"), UNIQUE'Unds'ID{}("aa42337769dde4931feb212ffab11db05be4243c71f23aab2fb44236ca261eeb")] + +// rule `#lookup(_,_,_,_)_MICHELSON_OptionData_Map_TypeName_SimpleData_TypeName`(`_[_<-undef]`(_M,inj{SimpleData,KItem}(K)),KT,K,VT)=>`None_MICHELSON-COMMON-SYNTAX_OptionData`(.KList) requires `isValue(_,_)_MICHELSON_Bool_TypeName_Data`(KT,inj{SimpleData,Data}(K)) ensures #token("true","Bool") [UNIQUE_ID(08805f64e2109669cecd3660987506c049f88db71c6d9d1a4f5c87297684e95b), contentStartColumn(8), contentStartLine(1403), org.kframework.attributes.Location(Location(1397,8,1397,85)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol]), simplification] + axiom{R} \implies{R} ( + \equals{SortBool{},R}( + LblisValue'LParUndsCommUndsRParUnds'MICHELSON'Unds'Bool'Unds'TypeName'Unds'Data{}(VarKT:SortTypeName{},inj{SortSimpleData{}, SortData{}}(VarK:SortSimpleData{})), + \dv{SortBool{}}("true")), + \and{R} ( + \equals{SortOptionData{},R} ( + Lbl'Hash'lookup'LParUndsCommUndsCommUndsCommUndsRParUnds'MICHELSON'Unds'OptionData'Unds'Map'Unds'TypeName'Unds'SimpleData'Unds'TypeName{}(Lbl'UndsLSqBUnds-LT-'-undef'RSqB'{}(Var'Unds'M:SortMap{},inj{SortSimpleData{}, SortKItem{}}(VarK:SortSimpleData{})),VarKT:SortTypeName{},VarK:SortSimpleData{},VarVT:SortTypeName{}), + LblNone'Unds'MICHELSON-COMMON-SYNTAX'Unds'OptionData{}()), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("1403"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1397,8,1397,85)"), simplification{}(), UNIQUE'Unds'ID{}("08805f64e2109669cecd3660987506c049f88db71c6d9d1a4f5c87297684e95b")] + +// rule `#open(_)_K-IO_IOInt_String`(S)=>`#open(_,_)_K-IO_IOInt_String_String`(S,#token("\"r+\"","String")) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(7ad2779cd54b9009119458217cae5138026cc4ff244e54c28e64db21100f63d9), contentStartColumn(8), contentStartLine(2177), org.kframework.attributes.Location(Location(2177,8,2177,48)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortIOInt{},R} ( + Lbl'Hash'open'LParUndsRParUnds'K-IO'Unds'IOInt'Unds'String{}(VarS:SortString{}), + Lbl'Hash'open'LParUndsCommUndsRParUnds'K-IO'Unds'IOInt'Unds'String'Unds'String{}(VarS:SortString{},\dv{SortString{}}("r+"))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2177"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2177,8,2177,48)"), UNIQUE'Unds'ID{}("7ad2779cd54b9009119458217cae5138026cc4ff244e54c28e64db21100f63d9")] + +// rule `#stderr_K-IO_Int`(.KList)=>#token("2","Int") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(75e0a8082acda4cf1e29caa6aaafb7f9a421e16421a41f2006943d6fab17a162), contentStartColumn(8), contentStartLine(2274), org.kframework.attributes.Location(Location(2274,8,2274,20)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortInt{},R} ( + Lbl'Hash'stderr'Unds'K-IO'Unds'Int{}(), + \dv{SortInt{}}("2")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2274"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2274,8,2274,20)"), UNIQUE'Unds'ID{}("75e0a8082acda4cf1e29caa6aaafb7f9a421e16421a41f2006943d6fab17a162")] + +// rule `#stdin_K-IO_Int`(.KList)=>#token("0","Int") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(c7ffdc9908c28a954521816d680f4e5ec44a679c7231a8dd09d4700f50b6d8c3), contentStartColumn(8), contentStartLine(2272), org.kframework.attributes.Location(Location(2272,8,2272,19)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortInt{},R} ( + Lbl'Hash'stdin'Unds'K-IO'Unds'Int{}(), + \dv{SortInt{}}("0")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2272"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2272,8,2272,19)"), UNIQUE'Unds'ID{}("c7ffdc9908c28a954521816d680f4e5ec44a679c7231a8dd09d4700f50b6d8c3")] + +// rule `#stdout_K-IO_Int`(.KList)=>#token("1","Int") requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(4ad4f379ff9db687ff9dfd1b15052edbcd3342a2ed262ecdd38c769e177a592c), contentStartColumn(8), contentStartLine(2273), org.kframework.attributes.Location(Location(2273,8,2273,20)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortInt{},R} ( + Lbl'Hash'stdout'Unds'K-IO'Unds'Int{}(), + \dv{SortInt{}}("1")), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2273"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2273,8,2273,20)"), UNIQUE'Unds'ID{}("4ad4f379ff9db687ff9dfd1b15052edbcd3342a2ed262ecdd38c769e177a592c")] + +// rule `.Bytes_BYTES-HOOKED_Bytes`(.KList)=>`String2Bytes(_)_BYTES-HOOKED_Bytes_String`(#token("\"\"","String")) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(3e07808715f2071d49d0c4f55e52909bade19dc4ad649f402fcff9a1b73c2253), contentStartColumn(8), contentStartLine(1773), org.kframework.attributes.Location(Location(1773,8,1773,34)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + axiom{R} \implies{R} ( + \top{R}(), + \and{R} ( + \equals{SortBytes{},R} ( + Lbl'Stop'Bytes'Unds'BYTES-HOOKED'Unds'Bytes{}(), + LblString2Bytes'LParUndsRParUnds'BYTES-HOOKED'Unds'Bytes'Unds'String{}(\dv{SortString{}}(""))), + \top{R}())) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/ext/k/k-distribution/target/release/k/include/kframework/builtin/domains.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1773"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1773,8,1773,34)"), UNIQUE'Unds'ID{}("3e07808715f2071d49d0c4f55e52909bade19dc4ad649f402fcff9a1b73c2253")] + +// rule ``(``(``(PT) #as _25,_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,``(`#Bind(_,_)_MICHELSON_KItem_InternalStack_InternalStack`(inj{Stack,InternalStack}(`_;__MICHELSON-COMMON_Stack_StackElement_Stack`(`[__]_MICHELSON-COMMON_StackElement_TypeName_Data`(T,inj{SymbolicData,Data}(S)),SS)),inj{Stack,InternalStack}(`_;__MICHELSON-COMMON_Stack_StackElement_Stack`(`[__]_MICHELSON-COMMON_StackElement_TypeName_Data`(T,D),SS')))~>_DotVar2),_14,_15,_16,_17,_18,_19,_20,``(Syms),_21,_22,_23),_DotVar0)=>``(``(_25,_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,``(`#Bind(_,_)_MICHELSON_KItem_InternalStack_InternalStack`(inj{Stack,InternalStack}(SS),inj{Stack,InternalStack}(SS'))~>_DotVar2),_14,_15,_16,_17,_18,_19,_20,``(`_Map_`(`_|->_`(inj{SymbolicData,KItem}(S),inj{TypedSymbol,KItem}(`#TypedSymbol(_,_)_MICHELSON_TypedSymbol_TypeName_Data`(T,D))),Syms)),_21,_22,_23),_DotVar0) requires `notBool_`(`_in_keys(_)_MAP_Bool_KItem_Map`(inj{SymbolicData,KItem}(S),Syms)) ensures #token("true","Bool") [UNIQUE_ID(1e5365ac565070ac0758de97981202be6b4e5c2e5ba7fb999348e5eadb630850), contentStartColumn(8), contentStartLine(2079), org.kframework.attributes.Location(Location(2073,8,2080,37)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol])] + alias rule231LHS{}(SortData{},SortPreType{},SortSymbolicData{},SortStack{},SortStack{},SortMap{},SortTypeName{},SortParamvalueCell{},SortStoragetypeCell{},SortMychainidCell{},SortNonceCell{},SortBigmapsCell{},SortScriptCell{},SortStackCell{},SortInputstackCell{},SortExpectedCell{},SortPreCell{},SortPostCell{},SortInvsCell{},SortStoragevalueCell{},SortCutpointsCell{},SortReturncodeCell{},SortAssumeFailedCell{},SortTraceCell{},SortParamtypeCell{},SortMybalanceCell{},SortMyamountCell{},SortMynowCell{},SortMyaddrCell{},SortKnownaddrsCell{},SortSourceaddrCell{},SortSenderaddrCell{},SortGeneratedCounterCell{},SortK{}) : SortGeneratedTopCell{} + where rule231LHS{}(VarD:SortData{},VarPT:SortPreType{},VarS:SortSymbolicData{},VarSS:SortStack{},VarSS'Apos':SortStack{},VarSyms:SortMap{},VarT:SortTypeName{},Var'Unds'0:SortParamvalueCell{},Var'Unds'1:SortStoragetypeCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Var'Unds'14:SortStackCell{},Var'Unds'15:SortInputstackCell{},Var'Unds'16:SortExpectedCell{},Var'Unds'17:SortPreCell{},Var'Unds'18:SortPostCell{},Var'Unds'19:SortInvsCell{},Var'Unds'2:SortStoragevalueCell{},Var'Unds'20:SortCutpointsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{},Var'Unds'25:SortParamtypeCell{},Var'Unds'3:SortMybalanceCell{},Var'Unds'4:SortMyamountCell{},Var'Unds'5:SortMynowCell{},Var'Unds'6:SortMyaddrCell{},Var'Unds'7:SortKnownaddrsCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}) := + \and{SortGeneratedTopCell{}} ( + \equals{SortBool{},SortGeneratedTopCell{}}( + LblnotBool'Unds'{}(Lbl'Unds'in'Unds'keys'LParUndsRParUnds'MAP'Unds'Bool'Unds'KItem'Unds'Map{}(inj{SortSymbolicData{}, SortKItem{}}(VarS:SortSymbolicData{}),VarSyms:SortMap{})), + \dv{SortBool{}}("true")), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(\and{SortParamtypeCell{}}(Lbl'-LT-'paramtype'-GT-'{}(VarPT:SortPreType{}),Var'Unds'25:SortParamtypeCell{}),Var'Unds'0:SortParamvalueCell{},Var'Unds'1:SortStoragetypeCell{},Var'Unds'2:SortStoragevalueCell{},Var'Unds'3:SortMybalanceCell{},Var'Unds'4:SortMyamountCell{},Var'Unds'5:SortMynowCell{},Var'Unds'6:SortMyaddrCell{},Var'Unds'7:SortKnownaddrsCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(kseq{}(Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(inj{SortStack{}, SortInternalStack{}}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack{}(Lbl'LSqBUndsUndsRSqBUnds'MICHELSON-COMMON'Unds'StackElement'Unds'TypeName'Unds'Data{}(VarT:SortTypeName{},inj{SortSymbolicData{}, SortData{}}(VarS:SortSymbolicData{})),VarSS:SortStack{})),inj{SortStack{}, SortInternalStack{}}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack{}(Lbl'LSqBUndsUndsRSqBUnds'MICHELSON-COMMON'Unds'StackElement'Unds'TypeName'Unds'Data{}(VarT:SortTypeName{},VarD:SortData{}),VarSS'Apos':SortStack{}))),Var'Unds'DotVar2:SortK{})),Var'Unds'14:SortStackCell{},Var'Unds'15:SortInputstackCell{},Var'Unds'16:SortExpectedCell{},Var'Unds'17:SortPreCell{},Var'Unds'18:SortPostCell{},Var'Unds'19:SortInvsCell{},Var'Unds'20:SortCutpointsCell{},Lbl'-LT-'symbols'-GT-'{}(VarSyms:SortMap{}),Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{})) [] + + axiom{} \rewrites{SortGeneratedTopCell{}} ( + rule231LHS{}(VarD:SortData{},VarPT:SortPreType{},VarS:SortSymbolicData{},VarSS:SortStack{},VarSS'Apos':SortStack{},VarSyms:SortMap{},VarT:SortTypeName{},Var'Unds'0:SortParamvalueCell{},Var'Unds'1:SortStoragetypeCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Var'Unds'14:SortStackCell{},Var'Unds'15:SortInputstackCell{},Var'Unds'16:SortExpectedCell{},Var'Unds'17:SortPreCell{},Var'Unds'18:SortPostCell{},Var'Unds'19:SortInvsCell{},Var'Unds'2:SortStoragevalueCell{},Var'Unds'20:SortCutpointsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{},Var'Unds'25:SortParamtypeCell{},Var'Unds'3:SortMybalanceCell{},Var'Unds'4:SortMyamountCell{},Var'Unds'5:SortMynowCell{},Var'Unds'6:SortMyaddrCell{},Var'Unds'7:SortKnownaddrsCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}), + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'25:SortParamtypeCell{},Var'Unds'0:SortParamvalueCell{},Var'Unds'1:SortStoragetypeCell{},Var'Unds'2:SortStoragevalueCell{},Var'Unds'3:SortMybalanceCell{},Var'Unds'4:SortMyamountCell{},Var'Unds'5:SortMynowCell{},Var'Unds'6:SortMyaddrCell{},Var'Unds'7:SortKnownaddrsCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(kseq{}(Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(inj{SortStack{}, SortInternalStack{}}(VarSS:SortStack{}),inj{SortStack{}, SortInternalStack{}}(VarSS'Apos':SortStack{})),Var'Unds'DotVar2:SortK{})),Var'Unds'14:SortStackCell{},Var'Unds'15:SortInputstackCell{},Var'Unds'16:SortExpectedCell{},Var'Unds'17:SortPreCell{},Var'Unds'18:SortPostCell{},Var'Unds'19:SortInvsCell{},Var'Unds'20:SortCutpointsCell{},Lbl'-LT-'symbols'-GT-'{}(Lbl'Unds'Map'Unds'{}(Lbl'UndsPipe'-'-GT-Unds'{}(inj{SortSymbolicData{}, SortKItem{}}(VarS:SortSymbolicData{}),inj{SortTypedSymbol{}, SortKItem{}}(Lbl'Hash'TypedSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'TypedSymbol'Unds'TypeName'Unds'Data{}(VarT:SortTypeName{},VarD:SortData{}))),VarSyms:SortMap{})),Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{}))) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("2079"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2073,8,2080,37)"), UNIQUE'Unds'ID{}("1e5365ac565070ac0758de97981202be6b4e5c2e5ba7fb999348e5eadb630850")] + +// rule ``(``(``(PT) #as _25,_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,``(`#Bind(_,_)_MICHELSON_KItem_InternalStack_InternalStack`(inj{Stack,InternalStack}(`_;__MICHELSON-COMMON_Stack_StackElement_Stack`(`[__]_MICHELSON-COMMON_StackElement_TypeName_Data`(T,inj{SymbolicData,Data}(S)),SS)),inj{Stack,InternalStack}(`_;__MICHELSON-COMMON_Stack_StackElement_Stack`(`[__]_MICHELSON-COMMON_StackElement_TypeName_Data`(T,D1),SS')))~>_DotVar2),_14,_15,_16,_17,_18,_19,_20,``(`_Map_`(`_|->_`(inj{SymbolicData,KItem}(S),inj{TypedSymbol,KItem}(`#TypedSymbol(_,_)_MICHELSON_TypedSymbol_TypeName_Data`(T,D2))),_DotVar3)) #as _36,_21,_22,_23),_DotVar0)=>``(``(_25,_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,``(`#Bind(_,_)_MICHELSON_KItem_InternalStack_InternalStack`(inj{Stack,InternalStack}(SS),inj{Stack,InternalStack}(SS'))~>_DotVar2),_14,_15,_16,_17,_18,_19,_20,_36,_21,_22,_23),_DotVar0) requires `_==K_`(inj{Data,KItem}(D1),inj{Data,KItem}(D2)) ensures #token("true","Bool") [UNIQUE_ID(0cf35dc1b87606a915c425895f78285c5ce0071280ecba5703498a1754a6e46e), contentStartColumn(8), contentStartLine(2088), org.kframework.attributes.Location(Location(2082,8,2089,23)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody "requires" K [klabel(#ruleRequires), symbol])] + alias rule232LHS{}(SortData{},SortData{},SortPreType{},SortSymbolicData{},SortStack{},SortStack{},SortTypeName{},SortParamvalueCell{},SortStoragetypeCell{},SortMychainidCell{},SortNonceCell{},SortBigmapsCell{},SortScriptCell{},SortStackCell{},SortInputstackCell{},SortExpectedCell{},SortPreCell{},SortPostCell{},SortInvsCell{},SortStoragevalueCell{},SortCutpointsCell{},SortReturncodeCell{},SortAssumeFailedCell{},SortTraceCell{},SortParamtypeCell{},SortMybalanceCell{},SortSymbolsCell{},SortMyamountCell{},SortMynowCell{},SortMyaddrCell{},SortKnownaddrsCell{},SortSourceaddrCell{},SortSenderaddrCell{},SortGeneratedCounterCell{},SortK{},SortMap{}) : SortGeneratedTopCell{} + where rule232LHS{}(VarD1:SortData{},VarD2:SortData{},VarPT:SortPreType{},VarS:SortSymbolicData{},VarSS:SortStack{},VarSS'Apos':SortStack{},VarT:SortTypeName{},Var'Unds'0:SortParamvalueCell{},Var'Unds'1:SortStoragetypeCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Var'Unds'14:SortStackCell{},Var'Unds'15:SortInputstackCell{},Var'Unds'16:SortExpectedCell{},Var'Unds'17:SortPreCell{},Var'Unds'18:SortPostCell{},Var'Unds'19:SortInvsCell{},Var'Unds'2:SortStoragevalueCell{},Var'Unds'20:SortCutpointsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{},Var'Unds'25:SortParamtypeCell{},Var'Unds'3:SortMybalanceCell{},Var'Unds'36:SortSymbolsCell{},Var'Unds'4:SortMyamountCell{},Var'Unds'5:SortMynowCell{},Var'Unds'6:SortMyaddrCell{},Var'Unds'7:SortKnownaddrsCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{},Var'Unds'DotVar3:SortMap{}) := + \and{SortGeneratedTopCell{}} ( + \equals{SortBool{},SortGeneratedTopCell{}}( + Lbl'UndsEqlsEqls'K'Unds'{}(kseq{}(inj{SortData{}, SortKItem{}}(VarD1:SortData{}),dotk{}()),kseq{}(inj{SortData{}, SortKItem{}}(VarD2:SortData{}),dotk{}())), + \dv{SortBool{}}("true")), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(\and{SortParamtypeCell{}}(Lbl'-LT-'paramtype'-GT-'{}(VarPT:SortPreType{}),Var'Unds'25:SortParamtypeCell{}),Var'Unds'0:SortParamvalueCell{},Var'Unds'1:SortStoragetypeCell{},Var'Unds'2:SortStoragevalueCell{},Var'Unds'3:SortMybalanceCell{},Var'Unds'4:SortMyamountCell{},Var'Unds'5:SortMynowCell{},Var'Unds'6:SortMyaddrCell{},Var'Unds'7:SortKnownaddrsCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(kseq{}(Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(inj{SortStack{}, SortInternalStack{}}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack{}(Lbl'LSqBUndsUndsRSqBUnds'MICHELSON-COMMON'Unds'StackElement'Unds'TypeName'Unds'Data{}(VarT:SortTypeName{},inj{SortSymbolicData{}, SortData{}}(VarS:SortSymbolicData{})),VarSS:SortStack{})),inj{SortStack{}, SortInternalStack{}}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack{}(Lbl'LSqBUndsUndsRSqBUnds'MICHELSON-COMMON'Unds'StackElement'Unds'TypeName'Unds'Data{}(VarT:SortTypeName{},VarD1:SortData{}),VarSS'Apos':SortStack{}))),Var'Unds'DotVar2:SortK{})),Var'Unds'14:SortStackCell{},Var'Unds'15:SortInputstackCell{},Var'Unds'16:SortExpectedCell{},Var'Unds'17:SortPreCell{},Var'Unds'18:SortPostCell{},Var'Unds'19:SortInvsCell{},Var'Unds'20:SortCutpointsCell{},\and{SortSymbolsCell{}}(Lbl'-LT-'symbols'-GT-'{}(Lbl'Unds'Map'Unds'{}(Lbl'UndsPipe'-'-GT-Unds'{}(inj{SortSymbolicData{}, SortKItem{}}(VarS:SortSymbolicData{}),inj{SortTypedSymbol{}, SortKItem{}}(Lbl'Hash'TypedSymbol'LParUndsCommUndsRParUnds'MICHELSON'Unds'TypedSymbol'Unds'TypeName'Unds'Data{}(VarT:SortTypeName{},VarD2:SortData{}))),Var'Unds'DotVar3:SortMap{})),Var'Unds'36:SortSymbolsCell{}),Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{})) [] + + axiom{} \rewrites{SortGeneratedTopCell{}} ( + rule232LHS{}(VarD1:SortData{},VarD2:SortData{},VarPT:SortPreType{},VarS:SortSymbolicData{},VarSS:SortStack{},VarSS'Apos':SortStack{},VarT:SortTypeName{},Var'Unds'0:SortParamvalueCell{},Var'Unds'1:SortStoragetypeCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Var'Unds'14:SortStackCell{},Var'Unds'15:SortInputstackCell{},Var'Unds'16:SortExpectedCell{},Var'Unds'17:SortPreCell{},Var'Unds'18:SortPostCell{},Var'Unds'19:SortInvsCell{},Var'Unds'2:SortStoragevalueCell{},Var'Unds'20:SortCutpointsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{},Var'Unds'25:SortParamtypeCell{},Var'Unds'3:SortMybalanceCell{},Var'Unds'36:SortSymbolsCell{},Var'Unds'4:SortMyamountCell{},Var'Unds'5:SortMynowCell{},Var'Unds'6:SortMyaddrCell{},Var'Unds'7:SortKnownaddrsCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{},Var'Unds'DotVar3:SortMap{}), + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'25:SortParamtypeCell{},Var'Unds'0:SortParamvalueCell{},Var'Unds'1:SortStoragetypeCell{},Var'Unds'2:SortStoragevalueCell{},Var'Unds'3:SortMybalanceCell{},Var'Unds'4:SortMyamountCell{},Var'Unds'5:SortMynowCell{},Var'Unds'6:SortMyaddrCell{},Var'Unds'7:SortKnownaddrsCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(kseq{}(Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(inj{SortStack{}, SortInternalStack{}}(VarSS:SortStack{}),inj{SortStack{}, SortInternalStack{}}(VarSS'Apos':SortStack{})),Var'Unds'DotVar2:SortK{})),Var'Unds'14:SortStackCell{},Var'Unds'15:SortInputstackCell{},Var'Unds'16:SortExpectedCell{},Var'Unds'17:SortPreCell{},Var'Unds'18:SortPostCell{},Var'Unds'19:SortInvsCell{},Var'Unds'20:SortCutpointsCell{},Var'Unds'36:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{}))) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody \"requires\" K [klabel(#ruleRequires), symbol]"), contentStartLine{}("2088"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2082,8,2089,23)"), UNIQUE'Unds'ID{}("0cf35dc1b87606a915c425895f78285c5ce0071280ecba5703498a1754a6e46e")] + +// rule ``(``(``(inj{Type,PreType}(PT)) #as _23,``(inj{Data,PreData}(P)) #as _25,``(inj{Type,PreType}(ST)) #as _27,``(inj{Data,PreData}(S)) #as _29,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,``(`#LoadDefaultContractStack_MICHELSON_KItem`(.KList)~>_DotVar2) #as _31,``(inj{Stack,InternalStack}(_0)),_12,_13,_14,_15,_16,_17,_18,_19,_20,_21),_DotVar0)=>``(``(_23,_25,_27,_29,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_31,``(inj{Stack,InternalStack}(`_;__MICHELSON-COMMON_Stack_StackElement_Stack`(`[__]_MICHELSON-COMMON_StackElement_TypeName_Data`(`____MICHELSON-COMMON_TypeName_BinaryTypeName_TypeName_TypeName`(`pair_MICHELSON-COMMON-SYNTAX_BinaryTypeName`(.KList),`#Name(_)_MICHELSON-COMMON_TypeName_Type`(PT),`#Name(_)_MICHELSON-COMMON_TypeName_Type`(ST)),inj{Pair,Data}(`Pair___MICHELSON-COMMON-SYNTAX_Pair_Data_Data`(P,S))),`.List{"_;__MICHELSON-COMMON_Stack_StackElement_Stack"}_Stack`(.KList)))),_12,_13,_14,_15,_16,_17,_18,_19,_20,_21),_DotVar0) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(c2afa7bcaf3e7ad15d0623b1007e81fda7c0ff0118f8ef4c5986a6764f6bd780), contentStartColumn(8), contentStartLine(596), org.kframework.attributes.Location(Location(596,8,603,39)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + alias rule233LHS{}(SortData{},SortType{},SortData{},SortType{},SortStack{},SortMybalanceCell{},SortBigmapsCell{},SortScriptCell{},SortInputstackCell{},SortExpectedCell{},SortPreCell{},SortPostCell{},SortInvsCell{},SortCutpointsCell{},SortSymbolsCell{},SortReturncodeCell{},SortMyamountCell{},SortAssumeFailedCell{},SortTraceCell{},SortParamtypeCell{},SortParamvalueCell{},SortStoragetypeCell{},SortStoragevalueCell{},SortMynowCell{},SortKCell{},SortMyaddrCell{},SortKnownaddrsCell{},SortSourceaddrCell{},SortSenderaddrCell{},SortMychainidCell{},SortNonceCell{},SortGeneratedCounterCell{},SortK{}) : SortGeneratedTopCell{} + where rule233LHS{}(VarP:SortData{},VarPT:SortType{},VarS:SortData{},VarST:SortType{},Var'Unds'0:SortStack{},Var'Unds'1:SortMybalanceCell{},Var'Unds'10:SortBigmapsCell{},Var'Unds'11:SortScriptCell{},Var'Unds'12:SortInputstackCell{},Var'Unds'13:SortExpectedCell{},Var'Unds'14:SortPreCell{},Var'Unds'15:SortPostCell{},Var'Unds'16:SortInvsCell{},Var'Unds'17:SortCutpointsCell{},Var'Unds'18:SortSymbolsCell{},Var'Unds'19:SortReturncodeCell{},Var'Unds'2:SortMyamountCell{},Var'Unds'20:SortAssumeFailedCell{},Var'Unds'21:SortTraceCell{},Var'Unds'23:SortParamtypeCell{},Var'Unds'25:SortParamvalueCell{},Var'Unds'27:SortStoragetypeCell{},Var'Unds'29:SortStoragevalueCell{},Var'Unds'3:SortMynowCell{},Var'Unds'31:SortKCell{},Var'Unds'4:SortMyaddrCell{},Var'Unds'5:SortKnownaddrsCell{},Var'Unds'6:SortSourceaddrCell{},Var'Unds'7:SortSenderaddrCell{},Var'Unds'8:SortMychainidCell{},Var'Unds'9:SortNonceCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}) := + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(\and{SortParamtypeCell{}}(Lbl'-LT-'paramtype'-GT-'{}(inj{SortType{}, SortPreType{}}(VarPT:SortType{})),Var'Unds'23:SortParamtypeCell{}),\and{SortParamvalueCell{}}(Lbl'-LT-'paramvalue'-GT-'{}(inj{SortData{}, SortPreData{}}(VarP:SortData{})),Var'Unds'25:SortParamvalueCell{}),\and{SortStoragetypeCell{}}(Lbl'-LT-'storagetype'-GT-'{}(inj{SortType{}, SortPreType{}}(VarST:SortType{})),Var'Unds'27:SortStoragetypeCell{}),\and{SortStoragevalueCell{}}(Lbl'-LT-'storagevalue'-GT-'{}(inj{SortData{}, SortPreData{}}(VarS:SortData{})),Var'Unds'29:SortStoragevalueCell{}),Var'Unds'1:SortMybalanceCell{},Var'Unds'2:SortMyamountCell{},Var'Unds'3:SortMynowCell{},Var'Unds'4:SortMyaddrCell{},Var'Unds'5:SortKnownaddrsCell{},Var'Unds'6:SortSourceaddrCell{},Var'Unds'7:SortSenderaddrCell{},Var'Unds'8:SortMychainidCell{},Var'Unds'9:SortNonceCell{},Var'Unds'10:SortBigmapsCell{},Var'Unds'11:SortScriptCell{},\and{SortKCell{}}(Lbl'-LT-'k'-GT-'{}(kseq{}(Lbl'Hash'LoadDefaultContractStack'Unds'MICHELSON'Unds'KItem{}(),Var'Unds'DotVar2:SortK{})),Var'Unds'31:SortKCell{}),Lbl'-LT-'stack'-GT-'{}(inj{SortStack{}, SortInternalStack{}}(Var'Unds'0:SortStack{})),Var'Unds'12:SortInputstackCell{},Var'Unds'13:SortExpectedCell{},Var'Unds'14:SortPreCell{},Var'Unds'15:SortPostCell{},Var'Unds'16:SortInvsCell{},Var'Unds'17:SortCutpointsCell{},Var'Unds'18:SortSymbolsCell{},Var'Unds'19:SortReturncodeCell{},Var'Unds'20:SortAssumeFailedCell{},Var'Unds'21:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{})) [] + + axiom{} \rewrites{SortGeneratedTopCell{}} ( + rule233LHS{}(VarP:SortData{},VarPT:SortType{},VarS:SortData{},VarST:SortType{},Var'Unds'0:SortStack{},Var'Unds'1:SortMybalanceCell{},Var'Unds'10:SortBigmapsCell{},Var'Unds'11:SortScriptCell{},Var'Unds'12:SortInputstackCell{},Var'Unds'13:SortExpectedCell{},Var'Unds'14:SortPreCell{},Var'Unds'15:SortPostCell{},Var'Unds'16:SortInvsCell{},Var'Unds'17:SortCutpointsCell{},Var'Unds'18:SortSymbolsCell{},Var'Unds'19:SortReturncodeCell{},Var'Unds'2:SortMyamountCell{},Var'Unds'20:SortAssumeFailedCell{},Var'Unds'21:SortTraceCell{},Var'Unds'23:SortParamtypeCell{},Var'Unds'25:SortParamvalueCell{},Var'Unds'27:SortStoragetypeCell{},Var'Unds'29:SortStoragevalueCell{},Var'Unds'3:SortMynowCell{},Var'Unds'31:SortKCell{},Var'Unds'4:SortMyaddrCell{},Var'Unds'5:SortKnownaddrsCell{},Var'Unds'6:SortSourceaddrCell{},Var'Unds'7:SortSenderaddrCell{},Var'Unds'8:SortMychainidCell{},Var'Unds'9:SortNonceCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}), + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'23:SortParamtypeCell{},Var'Unds'25:SortParamvalueCell{},Var'Unds'27:SortStoragetypeCell{},Var'Unds'29:SortStoragevalueCell{},Var'Unds'1:SortMybalanceCell{},Var'Unds'2:SortMyamountCell{},Var'Unds'3:SortMynowCell{},Var'Unds'4:SortMyaddrCell{},Var'Unds'5:SortKnownaddrsCell{},Var'Unds'6:SortSourceaddrCell{},Var'Unds'7:SortSenderaddrCell{},Var'Unds'8:SortMychainidCell{},Var'Unds'9:SortNonceCell{},Var'Unds'10:SortBigmapsCell{},Var'Unds'11:SortScriptCell{},Var'Unds'31:SortKCell{},Lbl'-LT-'stack'-GT-'{}(inj{SortStack{}, SortInternalStack{}}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack{}(Lbl'LSqBUndsUndsRSqBUnds'MICHELSON-COMMON'Unds'StackElement'Unds'TypeName'Unds'Data{}(Lbl'UndsUndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'BinaryTypeName'Unds'TypeName'Unds'TypeName{}(Lblpair'Unds'MICHELSON-COMMON-SYNTAX'Unds'BinaryTypeName{}(),Lbl'Hash'Name'LParUndsRParUnds'MICHELSON-COMMON'Unds'TypeName'Unds'Type{}(VarPT:SortType{}),Lbl'Hash'Name'LParUndsRParUnds'MICHELSON-COMMON'Unds'TypeName'Unds'Type{}(VarST:SortType{})),inj{SortPair{}, SortData{}}(LblPair'UndsUndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Pair'Unds'Data'Unds'Data{}(VarP:SortData{},VarS:SortData{}))),Lbl'Stop'List'LBraQuotUndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack'QuotRBraUnds'Stack{}()))),Var'Unds'12:SortInputstackCell{},Var'Unds'13:SortExpectedCell{},Var'Unds'14:SortPreCell{},Var'Unds'15:SortPostCell{},Var'Unds'16:SortInvsCell{},Var'Unds'17:SortCutpointsCell{},Var'Unds'18:SortSymbolsCell{},Var'Unds'19:SortReturncodeCell{},Var'Unds'20:SortAssumeFailedCell{},Var'Unds'21:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{}))) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("596"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(596,8,603,39)"), UNIQUE'Unds'ID{}("c2afa7bcaf3e7ad15d0623b1007e81fda7c0ff0118f8ef4c5986a6764f6bd780")] + +// rule ``(``(``(inj{Type,PreType}(T)) #as _24,_0,_1,_2,_3,_4,_5,``(A) #as _26,_6,_7,_8,_9,_10,_11,_12,``(inj{Instruction,KItem}(`SELF__MICHELSON-COMMON-SYNTAX_Instruction_AnnotationList`(Ann))~>_DotVar2),``(inj{Stack,InternalStack}(SS)),_13,_14,_15,_16,_17,_18,_19,_20,_21,_22),_DotVar0)=>``(``(_24,_0,_1,_2,_3,_4,_5,_26,_6,_7,_8,_9,_10,_11,_12,``(_DotVar2),``(inj{Stack,InternalStack}(`_;__MICHELSON-COMMON_Stack_StackElement_Stack`(`[__]_MICHELSON-COMMON_StackElement_TypeName_Data`(`___MICHELSON-COMMON_TypeName_UnaryTypeName_TypeName`(`contract_MICHELSON-COMMON-SYNTAX_UnaryTypeName`(.KList),`#Name(_)_MICHELSON-COMMON_TypeName_Type`(T)),inj{ContractData,Data}(`#Contract(_,_)_MICHELSON-COMMON_ContractData_Address_Type`(A,T))),SS))),_13,_14,_15,_16,_17,_18,_19,_20,_21,_22),_DotVar0) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(295b473e2220982231b0b9b68e145e328250bd48626419639506cbf079695789), contentStartColumn(8), contentStartLine(1758), org.kframework.attributes.Location(Location(1752,8,1755,28)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + alias rule234LHS{}(SortAddress{},SortAnnotationList{},SortStack{},SortType{},SortParamvalueCell{},SortStoragetypeCell{},SortNonceCell{},SortBigmapsCell{},SortScriptCell{},SortInputstackCell{},SortExpectedCell{},SortPreCell{},SortPostCell{},SortInvsCell{},SortCutpointsCell{},SortSymbolsCell{},SortStoragevalueCell{},SortReturncodeCell{},SortAssumeFailedCell{},SortTraceCell{},SortParamtypeCell{},SortMyaddrCell{},SortMybalanceCell{},SortMyamountCell{},SortMynowCell{},SortKnownaddrsCell{},SortSourceaddrCell{},SortSenderaddrCell{},SortMychainidCell{},SortGeneratedCounterCell{},SortK{}) : SortGeneratedTopCell{} + where rule234LHS{}(VarA:SortAddress{},VarAnn:SortAnnotationList{},VarSS:SortStack{},VarT:SortType{},Var'Unds'0:SortParamvalueCell{},Var'Unds'1:SortStoragetypeCell{},Var'Unds'10:SortNonceCell{},Var'Unds'11:SortBigmapsCell{},Var'Unds'12:SortScriptCell{},Var'Unds'13:SortInputstackCell{},Var'Unds'14:SortExpectedCell{},Var'Unds'15:SortPreCell{},Var'Unds'16:SortPostCell{},Var'Unds'17:SortInvsCell{},Var'Unds'18:SortCutpointsCell{},Var'Unds'19:SortSymbolsCell{},Var'Unds'2:SortStoragevalueCell{},Var'Unds'20:SortReturncodeCell{},Var'Unds'21:SortAssumeFailedCell{},Var'Unds'22:SortTraceCell{},Var'Unds'24:SortParamtypeCell{},Var'Unds'26:SortMyaddrCell{},Var'Unds'3:SortMybalanceCell{},Var'Unds'4:SortMyamountCell{},Var'Unds'5:SortMynowCell{},Var'Unds'6:SortKnownaddrsCell{},Var'Unds'7:SortSourceaddrCell{},Var'Unds'8:SortSenderaddrCell{},Var'Unds'9:SortMychainidCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}) := + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(\and{SortParamtypeCell{}}(Lbl'-LT-'paramtype'-GT-'{}(inj{SortType{}, SortPreType{}}(VarT:SortType{})),Var'Unds'24:SortParamtypeCell{}),Var'Unds'0:SortParamvalueCell{},Var'Unds'1:SortStoragetypeCell{},Var'Unds'2:SortStoragevalueCell{},Var'Unds'3:SortMybalanceCell{},Var'Unds'4:SortMyamountCell{},Var'Unds'5:SortMynowCell{},\and{SortMyaddrCell{}}(Lbl'-LT-'myaddr'-GT-'{}(VarA:SortAddress{}),Var'Unds'26:SortMyaddrCell{}),Var'Unds'6:SortKnownaddrsCell{},Var'Unds'7:SortSourceaddrCell{},Var'Unds'8:SortSenderaddrCell{},Var'Unds'9:SortMychainidCell{},Var'Unds'10:SortNonceCell{},Var'Unds'11:SortBigmapsCell{},Var'Unds'12:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(kseq{}(inj{SortInstruction{}, SortKItem{}}(LblSELF'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(VarAnn:SortAnnotationList{})),Var'Unds'DotVar2:SortK{})),Lbl'-LT-'stack'-GT-'{}(inj{SortStack{}, SortInternalStack{}}(VarSS:SortStack{})),Var'Unds'13:SortInputstackCell{},Var'Unds'14:SortExpectedCell{},Var'Unds'15:SortPreCell{},Var'Unds'16:SortPostCell{},Var'Unds'17:SortInvsCell{},Var'Unds'18:SortCutpointsCell{},Var'Unds'19:SortSymbolsCell{},Var'Unds'20:SortReturncodeCell{},Var'Unds'21:SortAssumeFailedCell{},Var'Unds'22:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{})) [] + + axiom{} \rewrites{SortGeneratedTopCell{}} ( + rule234LHS{}(VarA:SortAddress{},VarAnn:SortAnnotationList{},VarSS:SortStack{},VarT:SortType{},Var'Unds'0:SortParamvalueCell{},Var'Unds'1:SortStoragetypeCell{},Var'Unds'10:SortNonceCell{},Var'Unds'11:SortBigmapsCell{},Var'Unds'12:SortScriptCell{},Var'Unds'13:SortInputstackCell{},Var'Unds'14:SortExpectedCell{},Var'Unds'15:SortPreCell{},Var'Unds'16:SortPostCell{},Var'Unds'17:SortInvsCell{},Var'Unds'18:SortCutpointsCell{},Var'Unds'19:SortSymbolsCell{},Var'Unds'2:SortStoragevalueCell{},Var'Unds'20:SortReturncodeCell{},Var'Unds'21:SortAssumeFailedCell{},Var'Unds'22:SortTraceCell{},Var'Unds'24:SortParamtypeCell{},Var'Unds'26:SortMyaddrCell{},Var'Unds'3:SortMybalanceCell{},Var'Unds'4:SortMyamountCell{},Var'Unds'5:SortMynowCell{},Var'Unds'6:SortKnownaddrsCell{},Var'Unds'7:SortSourceaddrCell{},Var'Unds'8:SortSenderaddrCell{},Var'Unds'9:SortMychainidCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}), + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'24:SortParamtypeCell{},Var'Unds'0:SortParamvalueCell{},Var'Unds'1:SortStoragetypeCell{},Var'Unds'2:SortStoragevalueCell{},Var'Unds'3:SortMybalanceCell{},Var'Unds'4:SortMyamountCell{},Var'Unds'5:SortMynowCell{},Var'Unds'26:SortMyaddrCell{},Var'Unds'6:SortKnownaddrsCell{},Var'Unds'7:SortSourceaddrCell{},Var'Unds'8:SortSenderaddrCell{},Var'Unds'9:SortMychainidCell{},Var'Unds'10:SortNonceCell{},Var'Unds'11:SortBigmapsCell{},Var'Unds'12:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(Var'Unds'DotVar2:SortK{}),Lbl'-LT-'stack'-GT-'{}(inj{SortStack{}, SortInternalStack{}}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack{}(Lbl'LSqBUndsUndsRSqBUnds'MICHELSON-COMMON'Unds'StackElement'Unds'TypeName'Unds'Data{}(Lbl'UndsUndsUnds'MICHELSON-COMMON'Unds'TypeName'Unds'UnaryTypeName'Unds'TypeName{}(Lblcontract'Unds'MICHELSON-COMMON-SYNTAX'Unds'UnaryTypeName{}(),Lbl'Hash'Name'LParUndsRParUnds'MICHELSON-COMMON'Unds'TypeName'Unds'Type{}(VarT:SortType{})),inj{SortContractData{}, SortData{}}(Lbl'Hash'Contract'LParUndsCommUndsRParUnds'MICHELSON-COMMON'Unds'ContractData'Unds'Address'Unds'Type{}(VarA:SortAddress{},VarT:SortType{}))),VarSS:SortStack{}))),Var'Unds'13:SortInputstackCell{},Var'Unds'14:SortExpectedCell{},Var'Unds'15:SortPreCell{},Var'Unds'16:SortPostCell{},Var'Unds'17:SortInvsCell{},Var'Unds'18:SortCutpointsCell{},Var'Unds'19:SortSymbolsCell{},Var'Unds'20:SortReturncodeCell{},Var'Unds'21:SortAssumeFailedCell{},Var'Unds'22:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{}))) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1758"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1752,8,1755,28)"), UNIQUE'Unds'ID{}("295b473e2220982231b0b9b68e145e328250bd48626419639506cbf079695789")] + +// rule ``(``(_0,_1,_2,_3,``(B) #as _25,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,``(inj{Instruction,KItem}(`BALANCE__MICHELSON-COMMON-SYNTAX_Instruction_AnnotationList`(A))~>_DotVar2),``(inj{Stack,InternalStack}(SS)),_14,_15,_16,_17,_18,_19,_20,_21,_22,_23),_DotVar0)=>``(``(_0,_1,_2,_3,_25,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,``(_DotVar2),``(inj{Stack,InternalStack}(`_;__MICHELSON-COMMON_Stack_StackElement_Stack`(`[__]_MICHELSON-COMMON_StackElement_TypeName_Data`(inj{NullaryTypeName,TypeName}(`mutez_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList)),inj{Mutez,Data}(B)),SS))),_14,_15,_16,_17,_18,_19,_20,_21,_22,_23),_DotVar0) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(516641787dfe7980dab71867e12198df0c23e7005ca939144c7eb0bb4ec2f053), contentStartColumn(8), contentStartLine(1743), org.kframework.attributes.Location(Location(1737,8,1739,34)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + alias rule235LHS{}(SortAnnotationList{},SortMutez{},SortStack{},SortParamtypeCell{},SortParamvalueCell{},SortMychainidCell{},SortNonceCell{},SortBigmapsCell{},SortScriptCell{},SortInputstackCell{},SortExpectedCell{},SortPreCell{},SortPostCell{},SortInvsCell{},SortCutpointsCell{},SortStoragetypeCell{},SortSymbolsCell{},SortReturncodeCell{},SortAssumeFailedCell{},SortTraceCell{},SortMybalanceCell{},SortStoragevalueCell{},SortMyamountCell{},SortMynowCell{},SortMyaddrCell{},SortKnownaddrsCell{},SortSourceaddrCell{},SortSenderaddrCell{},SortGeneratedCounterCell{},SortK{}) : SortGeneratedTopCell{} + where rule235LHS{}(VarA:SortAnnotationList{},VarB:SortMutez{},VarSS:SortStack{},Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{},Var'Unds'25:SortMybalanceCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMyamountCell{},Var'Unds'5:SortMynowCell{},Var'Unds'6:SortMyaddrCell{},Var'Unds'7:SortKnownaddrsCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}) := + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'3:SortStoragevalueCell{},\and{SortMybalanceCell{}}(Lbl'-LT-'mybalance'-GT-'{}(VarB:SortMutez{}),Var'Unds'25:SortMybalanceCell{}),Var'Unds'4:SortMyamountCell{},Var'Unds'5:SortMynowCell{},Var'Unds'6:SortMyaddrCell{},Var'Unds'7:SortKnownaddrsCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(kseq{}(inj{SortInstruction{}, SortKItem{}}(LblBALANCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(VarA:SortAnnotationList{})),Var'Unds'DotVar2:SortK{})),Lbl'-LT-'stack'-GT-'{}(inj{SortStack{}, SortInternalStack{}}(VarSS:SortStack{})),Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{})) [] + + axiom{} \rewrites{SortGeneratedTopCell{}} ( + rule235LHS{}(VarA:SortAnnotationList{},VarB:SortMutez{},VarSS:SortStack{},Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{},Var'Unds'25:SortMybalanceCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMyamountCell{},Var'Unds'5:SortMynowCell{},Var'Unds'6:SortMyaddrCell{},Var'Unds'7:SortKnownaddrsCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}), + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'25:SortMybalanceCell{},Var'Unds'4:SortMyamountCell{},Var'Unds'5:SortMynowCell{},Var'Unds'6:SortMyaddrCell{},Var'Unds'7:SortKnownaddrsCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(Var'Unds'DotVar2:SortK{}),Lbl'-LT-'stack'-GT-'{}(inj{SortStack{}, SortInternalStack{}}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack{}(Lbl'LSqBUndsUndsRSqBUnds'MICHELSON-COMMON'Unds'StackElement'Unds'TypeName'Unds'Data{}(inj{SortNullaryTypeName{}, SortTypeName{}}(Lblmutez'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}()),inj{SortMutez{}, SortData{}}(VarB:SortMutez{})),VarSS:SortStack{}))),Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{}))) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1743"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1737,8,1739,34)"), UNIQUE'Unds'ID{}("516641787dfe7980dab71867e12198df0c23e7005ca939144c7eb0bb4ec2f053")] + +// rule ``(``(_0,_1,_2,_3,_4,``(M) #as _25,_5,_6,_7,_8,_9,_10,_11,_12,_13,``(inj{Instruction,KItem}(`AMOUNT__MICHELSON-COMMON-SYNTAX_Instruction_AnnotationList`(Ann))~>_DotVar2),``(inj{Stack,InternalStack}(SS)),_14,_15,_16,_17,_18,_19,_20,_21,_22,_23),_DotVar0)=>``(``(_0,_1,_2,_3,_4,_25,_5,_6,_7,_8,_9,_10,_11,_12,_13,``(_DotVar2),``(inj{Stack,InternalStack}(`_;__MICHELSON-COMMON_Stack_StackElement_Stack`(`[__]_MICHELSON-COMMON_StackElement_TypeName_Data`(inj{NullaryTypeName,TypeName}(`mutez_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList)),inj{Mutez,Data}(M)),SS))),_14,_15,_16,_17,_18,_19,_20,_21,_22,_23),_DotVar0) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(ba4e97be173f1b175ad3e550ca5426921d647caa18733bffd383a8cac3ccb1e5), contentStartColumn(8), contentStartLine(1763), org.kframework.attributes.Location(Location(1757,8,1759,32)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + alias rule236LHS{}(SortAnnotationList{},SortMutez{},SortStack{},SortParamtypeCell{},SortParamvalueCell{},SortMychainidCell{},SortNonceCell{},SortBigmapsCell{},SortScriptCell{},SortInputstackCell{},SortExpectedCell{},SortPreCell{},SortPostCell{},SortInvsCell{},SortCutpointsCell{},SortStoragetypeCell{},SortSymbolsCell{},SortReturncodeCell{},SortAssumeFailedCell{},SortTraceCell{},SortMyamountCell{},SortStoragevalueCell{},SortMybalanceCell{},SortMynowCell{},SortMyaddrCell{},SortKnownaddrsCell{},SortSourceaddrCell{},SortSenderaddrCell{},SortGeneratedCounterCell{},SortK{}) : SortGeneratedTopCell{} + where rule236LHS{}(VarAnn:SortAnnotationList{},VarM:SortMutez{},VarSS:SortStack{},Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{},Var'Unds'25:SortMyamountCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMynowCell{},Var'Unds'6:SortMyaddrCell{},Var'Unds'7:SortKnownaddrsCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}) := + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},\and{SortMyamountCell{}}(Lbl'-LT-'myamount'-GT-'{}(VarM:SortMutez{}),Var'Unds'25:SortMyamountCell{}),Var'Unds'5:SortMynowCell{},Var'Unds'6:SortMyaddrCell{},Var'Unds'7:SortKnownaddrsCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(kseq{}(inj{SortInstruction{}, SortKItem{}}(LblAMOUNT'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(VarAnn:SortAnnotationList{})),Var'Unds'DotVar2:SortK{})),Lbl'-LT-'stack'-GT-'{}(inj{SortStack{}, SortInternalStack{}}(VarSS:SortStack{})),Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{})) [] + + axiom{} \rewrites{SortGeneratedTopCell{}} ( + rule236LHS{}(VarAnn:SortAnnotationList{},VarM:SortMutez{},VarSS:SortStack{},Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{},Var'Unds'25:SortMyamountCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMynowCell{},Var'Unds'6:SortMyaddrCell{},Var'Unds'7:SortKnownaddrsCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}), + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'25:SortMyamountCell{},Var'Unds'5:SortMynowCell{},Var'Unds'6:SortMyaddrCell{},Var'Unds'7:SortKnownaddrsCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(Var'Unds'DotVar2:SortK{}),Lbl'-LT-'stack'-GT-'{}(inj{SortStack{}, SortInternalStack{}}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack{}(Lbl'LSqBUndsUndsRSqBUnds'MICHELSON-COMMON'Unds'StackElement'Unds'TypeName'Unds'Data{}(inj{SortNullaryTypeName{}, SortTypeName{}}(Lblmutez'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}()),inj{SortMutez{}, SortData{}}(VarM:SortMutez{})),VarSS:SortStack{}))),Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{}))) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1763"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1757,8,1759,32)"), UNIQUE'Unds'ID{}("ba4e97be173f1b175ad3e550ca5426921d647caa18733bffd383a8cac3ccb1e5")] + +// rule ``(``(_0,_1,_2,_3,_4,_5,``(N) #as _25,_6,_7,_8,_9,_10,_11,_12,_13,``(inj{Instruction,KItem}(`NOW__MICHELSON-COMMON-SYNTAX_Instruction_AnnotationList`(A))~>_DotVar2),``(inj{Stack,InternalStack}(SS)),_14,_15,_16,_17,_18,_19,_20,_21,_22,_23),_DotVar0)=>``(``(_0,_1,_2,_3,_4,_5,_25,_6,_7,_8,_9,_10,_11,_12,_13,``(_DotVar2),``(inj{Stack,InternalStack}(`_;__MICHELSON-COMMON_Stack_StackElement_Stack`(`[__]_MICHELSON-COMMON_StackElement_TypeName_Data`(inj{NullaryTypeName,TypeName}(`timestamp_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList)),inj{Timestamp,Data}(N)),SS))),_14,_15,_16,_17,_18,_19,_20,_21,_22,_23),_DotVar0) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(d1d7c7fe4cd34a27ac3b603bc9a70a552e10800fffe927a4c35c5b8b22696f9e), contentStartColumn(8), contentStartLine(1771), org.kframework.attributes.Location(Location(1765,8,1767,26)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + alias rule237LHS{}(SortAnnotationList{},SortTimestamp{},SortStack{},SortParamtypeCell{},SortParamvalueCell{},SortMychainidCell{},SortNonceCell{},SortBigmapsCell{},SortScriptCell{},SortInputstackCell{},SortExpectedCell{},SortPreCell{},SortPostCell{},SortInvsCell{},SortCutpointsCell{},SortStoragetypeCell{},SortSymbolsCell{},SortReturncodeCell{},SortAssumeFailedCell{},SortTraceCell{},SortMynowCell{},SortStoragevalueCell{},SortMybalanceCell{},SortMyamountCell{},SortMyaddrCell{},SortKnownaddrsCell{},SortSourceaddrCell{},SortSenderaddrCell{},SortGeneratedCounterCell{},SortK{}) : SortGeneratedTopCell{} + where rule237LHS{}(VarA:SortAnnotationList{},VarN:SortTimestamp{},VarSS:SortStack{},Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{},Var'Unds'25:SortMynowCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMyaddrCell{},Var'Unds'7:SortKnownaddrsCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}) := + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},\and{SortMynowCell{}}(Lbl'-LT-'mynow'-GT-'{}(VarN:SortTimestamp{}),Var'Unds'25:SortMynowCell{}),Var'Unds'6:SortMyaddrCell{},Var'Unds'7:SortKnownaddrsCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(kseq{}(inj{SortInstruction{}, SortKItem{}}(LblNOW'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(VarA:SortAnnotationList{})),Var'Unds'DotVar2:SortK{})),Lbl'-LT-'stack'-GT-'{}(inj{SortStack{}, SortInternalStack{}}(VarSS:SortStack{})),Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{})) [] + + axiom{} \rewrites{SortGeneratedTopCell{}} ( + rule237LHS{}(VarA:SortAnnotationList{},VarN:SortTimestamp{},VarSS:SortStack{},Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{},Var'Unds'25:SortMynowCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMyaddrCell{},Var'Unds'7:SortKnownaddrsCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}), + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'25:SortMynowCell{},Var'Unds'6:SortMyaddrCell{},Var'Unds'7:SortKnownaddrsCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(Var'Unds'DotVar2:SortK{}),Lbl'-LT-'stack'-GT-'{}(inj{SortStack{}, SortInternalStack{}}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack{}(Lbl'LSqBUndsUndsRSqBUnds'MICHELSON-COMMON'Unds'StackElement'Unds'TypeName'Unds'Data{}(inj{SortNullaryTypeName{}, SortTypeName{}}(Lbltimestamp'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}()),inj{SortTimestamp{}, SortData{}}(VarN:SortTimestamp{})),VarSS:SortStack{}))),Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{}))) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1771"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1765,8,1767,26)"), UNIQUE'Unds'ID{}("d1d7c7fe4cd34a27ac3b603bc9a70a552e10800fffe927a4c35c5b8b22696f9e")] + +// rule ``(``(_0,_1,_2,_3,_4,_5,_6,_7,``(Addrs) #as _23,_8,_9,_10,_11,``(BigMaps) #as _24,_12,``(inj{Instruction,KItem}(`BIND___MICHELSON_Instruction_OutputStack_Block`(Shape,Block))~>_DotVar2),``(Stack) #as _29,_13,_14,_15,_16,_17,_18,``(Symbols) #as _30,_19,_20,_21),_DotVar0)=>``(``(_0,_1,_2,_3,_4,_5,_6,_7,_23,_8,_9,_10,_11,_24,_12,``(`#Bind(_,_)_MICHELSON_KItem_InternalStack_InternalStack`(`#LiteralStackToStack(_)_MICHELSON-COMMON_InternalStack_OutputStack`(Shape),Stack)~>inj{Block,KItem}(Block)~>`#RestoreSymbols(_)_MICHELSON_KItem_Map`(Symbols)~>_DotVar2),_29,_13,_14,_15,_16,_17,_18,_30,_19,_20,_21),_DotVar0) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(7658fdeaff11bf7c4174423af1887e16f75c7117ef968c538ee78c2830a2e1b4), contentStartColumn(8), contentStartLine(2059), org.kframework.attributes.Location(Location(2053,8,2062,30)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + alias rule238LHS{}(SortMap{},SortMap{},SortBlock{},SortOutputStack{},SortInternalStack{},SortMap{},SortParamtypeCell{},SortParamvalueCell{},SortMychainidCell{},SortNonceCell{},SortScriptCell{},SortInputstackCell{},SortExpectedCell{},SortPreCell{},SortPostCell{},SortInvsCell{},SortCutpointsCell{},SortReturncodeCell{},SortStoragetypeCell{},SortAssumeFailedCell{},SortTraceCell{},SortKnownaddrsCell{},SortBigmapsCell{},SortStackCell{},SortStoragevalueCell{},SortSymbolsCell{},SortMybalanceCell{},SortMyamountCell{},SortMynowCell{},SortMyaddrCell{},SortSourceaddrCell{},SortSenderaddrCell{},SortGeneratedCounterCell{},SortK{}) : SortGeneratedTopCell{} + where rule238LHS{}(VarAddrs:SortMap{},VarBigMaps:SortMap{},VarBlock:SortBlock{},VarShape:SortOutputStack{},VarStack:SortInternalStack{},VarSymbols:SortMap{},Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortScriptCell{},Var'Unds'13:SortInputstackCell{},Var'Unds'14:SortExpectedCell{},Var'Unds'15:SortPreCell{},Var'Unds'16:SortPostCell{},Var'Unds'17:SortInvsCell{},Var'Unds'18:SortCutpointsCell{},Var'Unds'19:SortReturncodeCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'20:SortAssumeFailedCell{},Var'Unds'21:SortTraceCell{},Var'Unds'23:SortKnownaddrsCell{},Var'Unds'24:SortBigmapsCell{},Var'Unds'29:SortStackCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'30:SortSymbolsCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}) := + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},\and{SortKnownaddrsCell{}}(Lbl'-LT-'knownaddrs'-GT-'{}(VarAddrs:SortMap{}),Var'Unds'23:SortKnownaddrsCell{}),Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},\and{SortBigmapsCell{}}(Lbl'-LT-'bigmaps'-GT-'{}(VarBigMaps:SortMap{}),Var'Unds'24:SortBigmapsCell{}),Var'Unds'12:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(kseq{}(inj{SortInstruction{}, SortKItem{}}(LblBIND'UndsUndsUnds'MICHELSON'Unds'Instruction'Unds'OutputStack'Unds'Block{}(VarShape:SortOutputStack{},VarBlock:SortBlock{})),Var'Unds'DotVar2:SortK{})),\and{SortStackCell{}}(Lbl'-LT-'stack'-GT-'{}(VarStack:SortInternalStack{}),Var'Unds'29:SortStackCell{}),Var'Unds'13:SortInputstackCell{},Var'Unds'14:SortExpectedCell{},Var'Unds'15:SortPreCell{},Var'Unds'16:SortPostCell{},Var'Unds'17:SortInvsCell{},Var'Unds'18:SortCutpointsCell{},\and{SortSymbolsCell{}}(Lbl'-LT-'symbols'-GT-'{}(VarSymbols:SortMap{}),Var'Unds'30:SortSymbolsCell{}),Var'Unds'19:SortReturncodeCell{},Var'Unds'20:SortAssumeFailedCell{},Var'Unds'21:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{})) [] + + axiom{} \rewrites{SortGeneratedTopCell{}} ( + rule238LHS{}(VarAddrs:SortMap{},VarBigMaps:SortMap{},VarBlock:SortBlock{},VarShape:SortOutputStack{},VarStack:SortInternalStack{},VarSymbols:SortMap{},Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortScriptCell{},Var'Unds'13:SortInputstackCell{},Var'Unds'14:SortExpectedCell{},Var'Unds'15:SortPreCell{},Var'Unds'16:SortPostCell{},Var'Unds'17:SortInvsCell{},Var'Unds'18:SortCutpointsCell{},Var'Unds'19:SortReturncodeCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'20:SortAssumeFailedCell{},Var'Unds'21:SortTraceCell{},Var'Unds'23:SortKnownaddrsCell{},Var'Unds'24:SortBigmapsCell{},Var'Unds'29:SortStackCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'30:SortSymbolsCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}), + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},Var'Unds'23:SortKnownaddrsCell{},Var'Unds'8:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'24:SortBigmapsCell{},Var'Unds'12:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(kseq{}(Lbl'Hash'Bind'LParUndsCommUndsRParUnds'MICHELSON'Unds'KItem'Unds'InternalStack'Unds'InternalStack{}(Lbl'Hash'LiteralStackToStack'LParUndsRParUnds'MICHELSON-COMMON'Unds'InternalStack'Unds'OutputStack{}(VarShape:SortOutputStack{}),VarStack:SortInternalStack{}),kseq{}(inj{SortBlock{}, SortKItem{}}(VarBlock:SortBlock{}),kseq{}(Lbl'Hash'RestoreSymbols'LParUndsRParUnds'MICHELSON'Unds'KItem'Unds'Map{}(VarSymbols:SortMap{}),Var'Unds'DotVar2:SortK{})))),Var'Unds'29:SortStackCell{},Var'Unds'13:SortInputstackCell{},Var'Unds'14:SortExpectedCell{},Var'Unds'15:SortPreCell{},Var'Unds'16:SortPostCell{},Var'Unds'17:SortInvsCell{},Var'Unds'18:SortCutpointsCell{},Var'Unds'30:SortSymbolsCell{},Var'Unds'19:SortReturncodeCell{},Var'Unds'20:SortAssumeFailedCell{},Var'Unds'21:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{}))) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("2059"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(2053,8,2062,30)"), UNIQUE'Unds'ID{}("7658fdeaff11bf7c4174423af1887e16f75c7117ef968c538ee78c2830a2e1b4")] + +// rule ``(``(_0,_1,_2,_3,_4,_5,_6,_7,_8,``(A) #as _25,_9,_10,_11,_12,_13,``(inj{Instruction,KItem}(`SOURCE__MICHELSON-COMMON-SYNTAX_Instruction_AnnotationList`(Ann))~>_DotVar2),``(inj{Stack,InternalStack}(SS)),_14,_15,_16,_17,_18,_19,_20,_21,_22,_23),_DotVar0)=>``(``(_0,_1,_2,_3,_4,_5,_6,_7,_8,_25,_9,_10,_11,_12,_13,``(_DotVar2),``(inj{Stack,InternalStack}(`_;__MICHELSON-COMMON_Stack_StackElement_Stack`(`[__]_MICHELSON-COMMON_StackElement_TypeName_Data`(inj{NullaryTypeName,TypeName}(`address_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList)),inj{Address,Data}(A)),SS))),_14,_15,_16,_17,_18,_19,_20,_21,_22,_23),_DotVar0) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(0bbb7746b137e6a91450ff5439fb852ea3f5782ec19ee8f0e546850cba253b5e), contentStartColumn(8), contentStartLine(1750), org.kframework.attributes.Location(Location(1744,8,1746,36)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + alias rule239LHS{}(SortAddress{},SortAnnotationList{},SortStack{},SortParamtypeCell{},SortParamvalueCell{},SortMychainidCell{},SortNonceCell{},SortBigmapsCell{},SortScriptCell{},SortInputstackCell{},SortExpectedCell{},SortPreCell{},SortPostCell{},SortInvsCell{},SortCutpointsCell{},SortStoragetypeCell{},SortSymbolsCell{},SortReturncodeCell{},SortAssumeFailedCell{},SortTraceCell{},SortSourceaddrCell{},SortStoragevalueCell{},SortMybalanceCell{},SortMyamountCell{},SortMynowCell{},SortMyaddrCell{},SortKnownaddrsCell{},SortSenderaddrCell{},SortGeneratedCounterCell{},SortK{}) : SortGeneratedTopCell{} + where rule239LHS{}(VarA:SortAddress{},VarAnn:SortAnnotationList{},VarSS:SortStack{},Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{},Var'Unds'25:SortSourceaddrCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},Var'Unds'8:SortKnownaddrsCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}) := + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},Var'Unds'8:SortKnownaddrsCell{},\and{SortSourceaddrCell{}}(Lbl'-LT-'sourceaddr'-GT-'{}(VarA:SortAddress{}),Var'Unds'25:SortSourceaddrCell{}),Var'Unds'9:SortSenderaddrCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(kseq{}(inj{SortInstruction{}, SortKItem{}}(LblSOURCE'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(VarAnn:SortAnnotationList{})),Var'Unds'DotVar2:SortK{})),Lbl'-LT-'stack'-GT-'{}(inj{SortStack{}, SortInternalStack{}}(VarSS:SortStack{})),Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{})) [] + + axiom{} \rewrites{SortGeneratedTopCell{}} ( + rule239LHS{}(VarA:SortAddress{},VarAnn:SortAnnotationList{},VarSS:SortStack{},Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{},Var'Unds'25:SortSourceaddrCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},Var'Unds'8:SortKnownaddrsCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}), + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},Var'Unds'8:SortKnownaddrsCell{},Var'Unds'25:SortSourceaddrCell{},Var'Unds'9:SortSenderaddrCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(Var'Unds'DotVar2:SortK{}),Lbl'-LT-'stack'-GT-'{}(inj{SortStack{}, SortInternalStack{}}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack{}(Lbl'LSqBUndsUndsRSqBUnds'MICHELSON-COMMON'Unds'StackElement'Unds'TypeName'Unds'Data{}(inj{SortNullaryTypeName{}, SortTypeName{}}(Lbladdress'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}()),inj{SortAddress{}, SortData{}}(VarA:SortAddress{})),VarSS:SortStack{}))),Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{}))) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1750"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1744,8,1746,36)"), UNIQUE'Unds'ID{}("0bbb7746b137e6a91450ff5439fb852ea3f5782ec19ee8f0e546850cba253b5e")] + +// rule ``(``(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,``(A) #as _25,_10,_11,_12,_13,``(inj{Instruction,KItem}(`SENDER__MICHELSON-COMMON-SYNTAX_Instruction_AnnotationList`(Ann))~>_DotVar2),``(inj{Stack,InternalStack}(SS)),_14,_15,_16,_17,_18,_19,_20,_21,_22,_23),_DotVar0)=>``(``(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_25,_10,_11,_12,_13,``(_DotVar2),``(inj{Stack,InternalStack}(`_;__MICHELSON-COMMON_Stack_StackElement_Stack`(`[__]_MICHELSON-COMMON_StackElement_TypeName_Data`(inj{NullaryTypeName,TypeName}(`address_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList)),inj{Address,Data}(A)),SS))),_14,_15,_16,_17,_18,_19,_20,_21,_22,_23),_DotVar0) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(7132e5877576a5cb024871d54bd022162215a3e7df6efcfedfe8d4eb96309ac2), contentStartColumn(8), contentStartLine(1754), org.kframework.attributes.Location(Location(1748,8,1750,36)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + alias rule240LHS{}(SortAddress{},SortAnnotationList{},SortStack{},SortParamtypeCell{},SortParamvalueCell{},SortMychainidCell{},SortNonceCell{},SortBigmapsCell{},SortScriptCell{},SortInputstackCell{},SortExpectedCell{},SortPreCell{},SortPostCell{},SortInvsCell{},SortCutpointsCell{},SortStoragetypeCell{},SortSymbolsCell{},SortReturncodeCell{},SortAssumeFailedCell{},SortTraceCell{},SortSenderaddrCell{},SortStoragevalueCell{},SortMybalanceCell{},SortMyamountCell{},SortMynowCell{},SortMyaddrCell{},SortKnownaddrsCell{},SortSourceaddrCell{},SortGeneratedCounterCell{},SortK{}) : SortGeneratedTopCell{} + where rule240LHS{}(VarA:SortAddress{},VarAnn:SortAnnotationList{},VarSS:SortStack{},Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{},Var'Unds'25:SortSenderaddrCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},Var'Unds'8:SortKnownaddrsCell{},Var'Unds'9:SortSourceaddrCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}) := + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},Var'Unds'8:SortKnownaddrsCell{},Var'Unds'9:SortSourceaddrCell{},\and{SortSenderaddrCell{}}(Lbl'-LT-'senderaddr'-GT-'{}(VarA:SortAddress{}),Var'Unds'25:SortSenderaddrCell{}),Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(kseq{}(inj{SortInstruction{}, SortKItem{}}(LblSENDER'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(VarAnn:SortAnnotationList{})),Var'Unds'DotVar2:SortK{})),Lbl'-LT-'stack'-GT-'{}(inj{SortStack{}, SortInternalStack{}}(VarSS:SortStack{})),Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{})) [] + + axiom{} \rewrites{SortGeneratedTopCell{}} ( + rule240LHS{}(VarA:SortAddress{},VarAnn:SortAnnotationList{},VarSS:SortStack{},Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{},Var'Unds'25:SortSenderaddrCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},Var'Unds'8:SortKnownaddrsCell{},Var'Unds'9:SortSourceaddrCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}), + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},Var'Unds'8:SortKnownaddrsCell{},Var'Unds'9:SortSourceaddrCell{},Var'Unds'25:SortSenderaddrCell{},Var'Unds'10:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(Var'Unds'DotVar2:SortK{}),Lbl'-LT-'stack'-GT-'{}(inj{SortStack{}, SortInternalStack{}}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack{}(Lbl'LSqBUndsUndsRSqBUnds'MICHELSON-COMMON'Unds'StackElement'Unds'TypeName'Unds'Data{}(inj{SortNullaryTypeName{}, SortTypeName{}}(Lbladdress'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}()),inj{SortAddress{}, SortData{}}(VarA:SortAddress{})),VarSS:SortStack{}))),Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{}))) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1754"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1748,8,1750,36)"), UNIQUE'Unds'ID{}("7132e5877576a5cb024871d54bd022162215a3e7df6efcfedfe8d4eb96309ac2")] + +// rule ``(``(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,``(C) #as _25,_11,_12,_13,``(inj{Instruction,KItem}(`CHAIN_ID__MICHELSON-COMMON-SYNTAX_Instruction_AnnotationList`(A))~>_DotVar2),``(inj{Stack,InternalStack}(SS)),_14,_15,_16,_17,_18,_19,_20,_21,_22,_23),_DotVar0)=>``(``(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_25,_11,_12,_13,``(_DotVar2),``(inj{Stack,InternalStack}(`_;__MICHELSON-COMMON_Stack_StackElement_Stack`(`[__]_MICHELSON-COMMON_StackElement_TypeName_Data`(inj{NullaryTypeName,TypeName}(`chain_id_MICHELSON-COMMON-SYNTAX_NullaryTypeName`(.KList)),inj{ChainId,Data}(C)),SS))),_14,_15,_16,_17,_18,_19,_20,_21,_22,_23),_DotVar0) requires #token("true","Bool") ensures #token("true","Bool") [UNIQUE_ID(8fb773a9f516d3a48d913804fdf779a21463012ba6736d22bed28fb6c971b317), contentStartColumn(8), contentStartLine(1767), org.kframework.attributes.Location(Location(1761,8,1763,34)), org.kframework.attributes.Source(Source(/Users/skeirik/work/michelson-semantics/./michelson.md)), org.kframework.definition.Production(syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol])] + alias rule241LHS{}(SortAnnotationList{},SortChainId{},SortStack{},SortParamtypeCell{},SortParamvalueCell{},SortSenderaddrCell{},SortNonceCell{},SortBigmapsCell{},SortScriptCell{},SortInputstackCell{},SortExpectedCell{},SortPreCell{},SortPostCell{},SortInvsCell{},SortCutpointsCell{},SortStoragetypeCell{},SortSymbolsCell{},SortReturncodeCell{},SortAssumeFailedCell{},SortTraceCell{},SortMychainidCell{},SortStoragevalueCell{},SortMybalanceCell{},SortMyamountCell{},SortMynowCell{},SortMyaddrCell{},SortKnownaddrsCell{},SortSourceaddrCell{},SortGeneratedCounterCell{},SortK{}) : SortGeneratedTopCell{} + where rule241LHS{}(VarA:SortAnnotationList{},VarC:SortChainId{},VarSS:SortStack{},Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'10:SortSenderaddrCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{},Var'Unds'25:SortMychainidCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},Var'Unds'8:SortKnownaddrsCell{},Var'Unds'9:SortSourceaddrCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}) := + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},Var'Unds'8:SortKnownaddrsCell{},Var'Unds'9:SortSourceaddrCell{},Var'Unds'10:SortSenderaddrCell{},\and{SortMychainidCell{}}(Lbl'-LT-'mychainid'-GT-'{}(VarC:SortChainId{}),Var'Unds'25:SortMychainidCell{}),Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(kseq{}(inj{SortInstruction{}, SortKItem{}}(LblCHAIN'Unds'ID'UndsUnds'MICHELSON-COMMON-SYNTAX'Unds'Instruction'Unds'AnnotationList{}(VarA:SortAnnotationList{})),Var'Unds'DotVar2:SortK{})),Lbl'-LT-'stack'-GT-'{}(inj{SortStack{}, SortInternalStack{}}(VarSS:SortStack{})),Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{})) [] + + axiom{} \rewrites{SortGeneratedTopCell{}} ( + rule241LHS{}(VarA:SortAnnotationList{},VarC:SortChainId{},VarSS:SortStack{},Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'10:SortSenderaddrCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{},Var'Unds'25:SortMychainidCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},Var'Unds'8:SortKnownaddrsCell{},Var'Unds'9:SortSourceaddrCell{},Var'Unds'DotVar0:SortGeneratedCounterCell{},Var'Unds'DotVar2:SortK{}), + \and{SortGeneratedTopCell{}} ( + \top{SortGeneratedTopCell{}}(), Lbl'-LT-'generatedTop'-GT-'{}(Lbl'-LT-'michelsonTop'-GT-'{}(Var'Unds'0:SortParamtypeCell{},Var'Unds'1:SortParamvalueCell{},Var'Unds'2:SortStoragetypeCell{},Var'Unds'3:SortStoragevalueCell{},Var'Unds'4:SortMybalanceCell{},Var'Unds'5:SortMyamountCell{},Var'Unds'6:SortMynowCell{},Var'Unds'7:SortMyaddrCell{},Var'Unds'8:SortKnownaddrsCell{},Var'Unds'9:SortSourceaddrCell{},Var'Unds'10:SortSenderaddrCell{},Var'Unds'25:SortMychainidCell{},Var'Unds'11:SortNonceCell{},Var'Unds'12:SortBigmapsCell{},Var'Unds'13:SortScriptCell{},Lbl'-LT-'k'-GT-'{}(Var'Unds'DotVar2:SortK{}),Lbl'-LT-'stack'-GT-'{}(inj{SortStack{}, SortInternalStack{}}(Lbl'UndsSClnUndsUnds'MICHELSON-COMMON'Unds'Stack'Unds'StackElement'Unds'Stack{}(Lbl'LSqBUndsUndsRSqBUnds'MICHELSON-COMMON'Unds'StackElement'Unds'TypeName'Unds'Data{}(inj{SortNullaryTypeName{}, SortTypeName{}}(Lblchain'Unds'id'Unds'MICHELSON-COMMON-SYNTAX'Unds'NullaryTypeName{}()),inj{SortChainId{}, SortData{}}(VarC:SortChainId{})),VarSS:SortStack{}))),Var'Unds'14:SortInputstackCell{},Var'Unds'15:SortExpectedCell{},Var'Unds'16:SortPreCell{},Var'Unds'17:SortPostCell{},Var'Unds'18:SortInvsCell{},Var'Unds'19:SortCutpointsCell{},Var'Unds'20:SortSymbolsCell{},Var'Unds'21:SortReturncodeCell{},Var'Unds'22:SortAssumeFailedCell{},Var'Unds'23:SortTraceCell{}),Var'Unds'DotVar0:SortGeneratedCounterCell{}))) + [org'Stop'kframework'Stop'attributes'Stop'Source{}("Source(/Users/skeirik/work/michelson-semantics/./michelson.md)"), org'Stop'kframework'Stop'definition'Stop'Production{}("syntax #RuleContent ::= #RuleBody [klabel(#ruleNoConditions), symbol]"), contentStartLine{}("1767"), contentStartColumn{}("8"), org'Stop'kframework'Stop'attributes'Stop'Location{}("Location(1761,8,1763,34)"), UNIQUE'Unds'ID{}("8fb773a9f516d3a48d913804fdf779a21463012ba6736d22bed28fb6c971b317")] + +// rule ``(``(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,`